Logo GNT
Actualités Tests & Guides Bons Plans
GTA 6 iPhone 17 Copilot Switch 2 Temu ChatGPT Tesla
OVH Cloud OVH Cloud
Entraide Développement Développement Visual Basic AND de deux tableaux

AND de deux tableaux

9 réponses
Avatar
christophe-pasde
Bonjour,

j'ai deux tableaux d'octets de dimension 1 et de taille égale.

Je souhaite faire tableau résultat = Tableaux1 and tableau 2

cad : For i&=0 to ubound(tabres): (tabres(i&)= tab1(i&) AND tab2(i&)

Les tableaux étant volumineux (11 000 octets) est-il possible
d'effectuer l'opération de manière globale, une sorte de movememory sur
la quelle on peut indiquer une opération logique, comme les rasterOP.
(il s'agit en fait d'additionner deux DIB)

Si quelqu'un a une piste,
Nb: la solution qui consiste à envoyer les deux DIB sur le bitmap d'un
DC puis d'utiliser getdibits est problématique compte tenu de la taille
des DIB.




Christophe
Signaler un problème avec ce contenu

9 réponses

Supprimer
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire

Veuillez sélectionner un problème

Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Avatar
LE TROLL
Salut,

j'comprends pas tout, lol, mais bon, j'ai retenu que tu as deux variable
indicées et que tu veux en faire une en gros (variable ou fichier, peu
importe), de 11.000 octets (11 ko))...

Ben on peut déjà, et faute de mieux, faire:

dim i as long
dim t1 as string
'-------------------------------------------
dim t2_1(5500) as string * 1 ' ton tabelau 1
dim t2_2(5500) as string * 1 ' ton tableau 2
'---si ça ne passe pas, faire as tring (tout court), car le "* x" est empilé
et dépilé je crois---
t1=""
for i = 1 to 5500
t1=t1 & t2_1(i)
next i
for i = 1 to 5500
t1=t1 & t2_1(i)
next i

Ensuite tu auras une chaîne, c'est mieux qu'un tableau, ça peut se prendre
en totalité ou à une position donné (mid()), et une boucle de 11.000 ça
devrait pas mettre 20 ans...

Tu peux aussi mettre ça dans une liste additem, et plein d'atre solution
sans doute...

Est-ce ça que tu veux ?
---------------------------


"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
message de news:415a705c$0$14613$
Bonjour,

j'ai deux tableaux d'octets de dimension 1 et de taille égale.

Je souhaite faire tableau résultat = Tableaux1 and tableau 2

cad : For i&=0 to ubound(tabres): (tabres(i&)= tab1(i&) AND tab2(i&)

Les tableaux étant volumineux (11 000 octets) est-il possible
d'effectuer l'opération de manière globale, une sorte de movememory sur
la quelle on peut indiquer une opération logique, comme les rasterOP.
(il s'agit en fait d'additionner deux DIB)

Si quelqu'un a une piste,
Nb: la solution qui consiste à envoyer les deux DIB sur le bitmap d'un
DC puis d'utiliser getdibits est problématique compte tenu de la taille
des DIB.




Christophe











Avatar
LE TROLL
Heu, erreur:

t1 = t1 & x(i)

évidemment :o)


"LE TROLL" <le a écrit dans le message de
news:
Salut,

j'comprends pas tout, lol, mais bon, j'ai retenu que tu as deux


variable
indicées et que tu veux en faire une en gros (variable ou fichier, peu
importe), de 11.000 octets (11 ko))...

Ben on peut déjà, et faute de mieux, faire:

dim i as long
dim t1 as string
'-------------------------------------------
dim t2_1(5500) as string * 1 ' ton tabelau 1
dim t2_2(5500) as string * 1 ' ton tableau 2
'---si ça ne passe pas, faire as tring (tout court), car le "* x" est


empilé
et dépilé je crois---
t1=""
for i = 1 to 5500
t1=t1 & t2_1(i)
next i
for i = 1 to 5500
t1=t1 & t2_1(i)
next i

Ensuite tu auras une chaîne, c'est mieux qu'un tableau, ça peut se prendre
en totalité ou à une position donné (mid()), et une boucle de 11.000 ça
devrait pas mettre 20 ans...

Tu peux aussi mettre ça dans une liste additem, et plein d'atre solution
sans doute...

Est-ce ça que tu veux ?
---------------------------


"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
message de news:415a705c$0$14613$
> Bonjour,
>
> j'ai deux tableaux d'octets de dimension 1 et de taille égale.
>
> Je souhaite faire tableau résultat = Tableaux1 and tableau 2
>
> cad : For i&=0 to ubound(tabres): (tabres(i&)= tab1(i&) AND tab2(i&)
>
> Les tableaux étant volumineux (11 000 octets) est-il possible
> d'effectuer l'opération de manière globale, une sorte de movememory sur
> la quelle on peut indiquer une opération logique, comme les rasterOP.
> (il s'agit en fait d'additionner deux DIB)
>
> Si quelqu'un a une piste,
> Nb: la solution qui consiste à envoyer les deux DIB sur le bitmap d'un
> DC puis d'utiliser getdibits est problématique compte tenu de la taille
> des DIB.
>
>
>
>
> Christophe
>
>
>
>
>
>
>
>
>




Avatar
christophe-pasde
bonjour,

me suis un peu trompé de trois zéro, il s'agit de 11 Mo ( 1400*8000 octet).

ce que je veux c'est éviter de boucler sur tous les éléments du tableau.

christophe


LE TROLL a écrit :

Heu, erreur:

t1 = t1 & x(i)

évidemment :o)


"LE TROLL" <le a écrit dans le message de
news:

Salut,

j'comprends pas tout, lol, mais bon, j'ai retenu que tu as deux



variable

indicées et que tu veux en faire une en gros (variable ou fichier, peu
importe), de 11.000 octets (11 ko))...

Ben on peut déjà, et faute de mieux, faire:

dim i as long
dim t1 as string
'-------------------------------------------
dim t2_1(5500) as string * 1 ' ton tabelau 1
dim t2_2(5500) as string * 1 ' ton tableau 2
'---si ça ne passe pas, faire as tring (tout court), car le "* x" est



empilé

et dépilé je crois---
t1=""
for i = 1 to 5500
t1=t1 & t2_1(i)
next i
for i = 1 to 5500
t1=t1 & t2_1(i)
next i

Ensuite tu auras une chaîne, c'est mieux qu'un tableau, ça peut se prendre
en totalité ou à une position donné (mid()), et une boucle de 11.000 ça
devrait pas mettre 20 ans...

Tu peux aussi mettre ça dans une liste additem, et plein d'atre solution
sans doute...

Est-ce ça que tu veux ?
---------------------------


"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
message de news:415a705c$0$14613$

Bonjour,

j'ai deux tableaux d'octets de dimension 1 et de taille égale.

Je souhaite faire tableau résultat = Tableaux1 and tableau 2

cad : For i&=0 to ubound(tabres): (tabres(i&)= tab1(i&) AND tab2(i&)

Les tableaux étant volumineux (11 000 octets) est-il possible
d'effectuer l'opération de manière globale, une sorte de movememory sur
la quelle on peut indiquer une opération logique, comme les rasterOP.
(il s'agit en fait d'additionner deux DIB)

Si quelqu'un a une piste,
Nb: la solution qui consiste à envoyer les deux DIB sur le bitmap d'un
DC puis d'utiliser getdibits est problématique compte tenu de la taille
des DIB.




Christophe



















Avatar
LE TROLL
Re-salut,

11 Mo, ouais, lol...

Mais déjà, ces 11 mo ils se trouvent bien quelque part à l'état naturel,
quand tu éteins ton PC, dans un fichier je présume, alors il serait bien de
savoir quel type de fichier et comment ils sont rangés, ce qui déterminerait
la façon de les happer ???
----------------------


"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
message de news:415a7ef8$0$27423$
bonjour,

me suis un peu trompé de trois zéro, il s'agit de 11 Mo ( 1400*8000


octet).

ce que je veux c'est éviter de boucler sur tous les éléments du tableau.

christophe


LE TROLL a écrit :

> Heu, erreur:
>
> t1 = t1 & x(i)
>
> évidemment :o)
>
>
> "LE TROLL" <le a écrit dans le message de
> news:
>
>> Salut,
>>
>> j'comprends pas tout, lol, mais bon, j'ai retenu que tu as deux
>
> variable
>
>>indicées et que tu veux en faire une en gros (variable ou fichier, peu
>>importe), de 11.000 octets (11 ko))...
>>
>> Ben on peut déjà, et faute de mieux, faire:
>>
>>dim i as long
>>dim t1 as string
>>'-------------------------------------------
>>dim t2_1(5500) as string * 1 ' ton tabelau 1
>>dim t2_2(5500) as string * 1 ' ton tableau 2
>>'---si ça ne passe pas, faire as tring (tout court), car le "* x" est
>
> empilé
>
>>et dépilé je crois---
>>t1=""
>>for i = 1 to 5500
>>t1=t1 & t2_1(i)
>>next i
>>for i = 1 to 5500
>>t1=t1 & t2_1(i)
>>next i
>>
>>Ensuite tu auras une chaîne, c'est mieux qu'un tableau, ça peut se


prendre
>>en totalité ou à une position donné (mid()), et une boucle de 11.000 ça
>>devrait pas mettre 20 ans...
>>
>>Tu peux aussi mettre ça dans une liste additem, et plein d'atre solution
>>sans doute...
>>
>>Est-ce ça que tu veux ?
>>---------------------------
>>
>>
>>"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
>>message de news:415a705c$0$14613$
>>
>>>Bonjour,
>>>
>>>j'ai deux tableaux d'octets de dimension 1 et de taille égale.
>>>
>>>Je souhaite faire tableau résultat = Tableaux1 and tableau 2
>>>
>>>cad : For i&=0 to ubound(tabres): (tabres(i&)= tab1(i&) AND tab2(i&)
>>>
>>>Les tableaux étant volumineux (11 000 octets) est-il possible
>>>d'effectuer l'opération de manière globale, une sorte de movememory sur
>>>la quelle on peut indiquer une opération logique, comme les rasterOP.
>>>(il s'agit en fait d'additionner deux DIB)
>>>
>>>Si quelqu'un a une piste,
>>>Nb: la solution qui consiste à envoyer les deux DIB sur le bitmap d'un
>>>DC puis d'utiliser getdibits est problématique compte tenu de la taille
>>>des DIB.
>>>
>>>
>>>
>>>
>>> Christophe
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>
>>
>
>


Avatar
Patrice Henrio
D'une part le "&" du texte n'a rien à voir avec and
1 & 2 = 12
1 and 2 = 0

Une des slutions pour diviser par N serait de considérer le tableau comme un
tableau d'un type de données numériques utilisant N octets et acceptant
l'opération and.
De mémoire on doit déjà pouvoir diviser par quatre en utilisant des long. Je
n'ai pas le temps de tester mais je verrai cela plus tard.
L'autre de créer une routine en C ou en assembleur permettant un et logique
entre deux zônes mémoires.

Je me demande même si on ne pourrait pas utiliser les routines API
d'affichage graphique. On n'arrivera pas aux 11 Mo mais on doit pouvoir
diviser au moins par Mille.

Pour la première solution supposons un tableau de 16 bytes que je transforme
en tableau de 4 long (simplement au niveau de la lecture des données dans un
fichier) au lieu d'une boucle de 16 passage, je n'en ai plus que 4.



"LE TROLL" <le a écrit dans le message de news:
%
Re-salut,

11 Mo, ouais, lol...

Mais déjà, ces 11 mo ils se trouvent bien quelque part à l'état
naturel,
quand tu éteins ton PC, dans un fichier je présume, alors il serait bien
de
savoir quel type de fichier et comment ils sont rangés, ce qui
déterminerait
la façon de les happer ???
----------------------


"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
message de news:415a7ef8$0$27423$
bonjour,

me suis un peu trompé de trois zéro, il s'agit de 11 Mo ( 1400*8000


octet).

ce que je veux c'est éviter de boucler sur tous les éléments du tableau.

christophe


LE TROLL a écrit :

> Heu, erreur:
>
> t1 = t1 & x(i)
>
> évidemment :o)
>
>
> "LE TROLL" <le a écrit dans le message de
> news:
>
>> Salut,
>>
>> j'comprends pas tout, lol, mais bon, j'ai retenu que tu as deux
>
> variable
>
>>indicées et que tu veux en faire une en gros (variable ou fichier, peu
>>importe), de 11.000 octets (11 ko))...
>>
>> Ben on peut déjà, et faute de mieux, faire:
>>
>>dim i as long
>>dim t1 as string
>>'-------------------------------------------
>>dim t2_1(5500) as string * 1 ' ton tabelau 1
>>dim t2_2(5500) as string * 1 ' ton tableau 2
>>'---si ça ne passe pas, faire as tring (tout court), car le "* x" est
>
> empilé
>
>>et dépilé je crois---
>>t1=""
>>for i = 1 to 5500
>>t1=t1 & t2_1(i)
>>next i
>>for i = 1 to 5500
>>t1=t1 & t2_1(i)
>>next i
>>
>>Ensuite tu auras une chaîne, c'est mieux qu'un tableau, ça peut se


prendre
>>en totalité ou à une position donné (mid()), et une boucle de 11.000 ça
>>devrait pas mettre 20 ans...
>>
>>Tu peux aussi mettre ça dans une liste additem, et plein d'atre
>>solution
>>sans doute...
>>
>>Est-ce ça que tu veux ?
>>---------------------------
>>
>>
>>"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
>>message de news:415a705c$0$14613$
>>
>>>Bonjour,
>>>
>>>j'ai deux tableaux d'octets de dimension 1 et de taille égale.
>>>
>>>Je souhaite faire tableau résultat = Tableaux1 and tableau 2
>>>
>>>cad : For i&=0 to ubound(tabres): (tabres(i&)= tab1(i&) AND tab2(i&)
>>>
>>>Les tableaux étant volumineux (11 000 octets) est-il possible
>>>d'effectuer l'opération de manière globale, une sorte de movememory
>>>sur
>>>la quelle on peut indiquer une opération logique, comme les rasterOP.
>>>(il s'agit en fait d'additionner deux DIB)
>>>
>>>Si quelqu'un a une piste,
>>>Nb: la solution qui consiste à envoyer les deux DIB sur le bitmap d'un
>>>DC puis d'utiliser getdibits est problématique compte tenu de la
>>>taille
>>>des DIB.
>>>
>>>
>>>
>>>
>>> Christophe
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>
>>
>
>






Avatar
LE TROLL
Je n'ai pas parlé de AND, j'ai dit que:

for i = 1 to 5500
variable_string = variable_string & tableau(i)
next i

Le tableau avait à l'époque (5,5 ko * 2 ) !!!

Ça, "&" ça marche, faut tout lire quand tu lis :o)
-------------

Sinon, c'est trouble le truc, car la personne parle de 11 ko, puis de 11
Mo (ok pour l'erreur), mais moi, il me semble qu'il faudrait déjà connaître
la source des datas (elles ne se baladent pas dans l'air), ça doit être un
fichier, en en connaissant le type et la structure ça serait mieux, et ça,
la personne n'en dit mot, elle ne dit pas non plus si l'opération est
destinée à être reproduite, ou si c'est une union définitive, etc...
Pourtant ça aiderait pour décider... In fine, cette personne ne veut pas
charger en boucle (semblant dire qu'elle sait le faire?), pourtant depuis
10h30 qu'elle a posé sa question, ça fait 4h00, même en boucle, ça serait
terminé, alors tu vois ce que je veux dire, je sens pas le truc, à toi de
voir...


"Patrice Henrio" a écrit dans le message de
news:
D'une part le "&" du texte n'a rien à voir avec and
1 & 2 = 12
1 and 2 = 0

Une des slutions pour diviser par N serait de considérer le tableau comme


un
tableau d'un type de données numériques utilisant N octets et acceptant
l'opération and.
De mémoire on doit déjà pouvoir diviser par quatre en utilisant des long.


Je
n'ai pas le temps de tester mais je verrai cela plus tard.
L'autre de créer une routine en C ou en assembleur permettant un et


logique
entre deux zônes mémoires.

Je me demande même si on ne pourrait pas utiliser les routines API
d'affichage graphique. On n'arrivera pas aux 11 Mo mais on doit pouvoir
diviser au moins par Mille.

Pour la première solution supposons un tableau de 16 bytes que je


transforme
en tableau de 4 long (simplement au niveau de la lecture des données dans


un
fichier) au lieu d'une boucle de 16 passage, je n'en ai plus que 4.



"LE TROLL" <le a écrit dans le message de news:
%
> Re-salut,
>
> 11 Mo, ouais, lol...
>
> Mais déjà, ces 11 mo ils se trouvent bien quelque part à l'état
> naturel,
> quand tu éteins ton PC, dans un fichier je présume, alors il serait bien
> de
> savoir quel type de fichier et comment ils sont rangés, ce qui
> déterminerait
> la façon de les happer ???
> ----------------------
>
>
> "christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
> message de news:415a7ef8$0$27423$
>> bonjour,
>>
>> me suis un peu trompé de trois zéro, il s'agit de 11 Mo ( 1400*8000
> octet).
>>
>> ce que je veux c'est éviter de boucler sur tous les éléments du


tableau.
>>
>> christophe
>>
>>
>> LE TROLL a écrit :
>>
>> > Heu, erreur:
>> >
>> > t1 = t1 & x(i)
>> >
>> > évidemment :o)
>> >
>> >
>> > "LE TROLL" <le a écrit dans le message de
>> > news:
>> >
>> >> Salut,
>> >>
>> >> j'comprends pas tout, lol, mais bon, j'ai retenu que tu as deux
>> >
>> > variable
>> >
>> >>indicées et que tu veux en faire une en gros (variable ou fichier,


peu
>> >>importe), de 11.000 octets (11 ko))...
>> >>
>> >> Ben on peut déjà, et faute de mieux, faire:
>> >>
>> >>dim i as long
>> >>dim t1 as string
>> >>'-------------------------------------------
>> >>dim t2_1(5500) as string * 1 ' ton tabelau 1
>> >>dim t2_2(5500) as string * 1 ' ton tableau 2
>> >>'---si ça ne passe pas, faire as tring (tout court), car le "* x" est
>> >
>> > empilé
>> >
>> >>et dépilé je crois---
>> >>t1=""
>> >>for i = 1 to 5500
>> >>t1=t1 & t2_1(i)
>> >>next i
>> >>for i = 1 to 5500
>> >>t1=t1 & t2_1(i)
>> >>next i
>> >>
>> >>Ensuite tu auras une chaîne, c'est mieux qu'un tableau, ça peut se
> prendre
>> >>en totalité ou à une position donné (mid()), et une boucle de 11.000


ça
>> >>devrait pas mettre 20 ans...
>> >>
>> >>Tu peux aussi mettre ça dans une liste additem, et plein d'atre
>> >>solution
>> >>sans doute...
>> >>
>> >>Est-ce ça que tu veux ?
>> >>---------------------------
>> >>
>> >>
>> >>"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans


le
>> >>message de news:415a705c$0$14613$
>> >>
>> >>>Bonjour,
>> >>>
>> >>>j'ai deux tableaux d'octets de dimension 1 et de taille égale.
>> >>>
>> >>>Je souhaite faire tableau résultat = Tableaux1 and tableau 2
>> >>>
>> >>>cad : For i&=0 to ubound(tabres): (tabres(i&)= tab1(i&) AND tab2(i&)
>> >>>
>> >>>Les tableaux étant volumineux (11 000 octets) est-il possible
>> >>>d'effectuer l'opération de manière globale, une sorte de movememory
>> >>>sur
>> >>>la quelle on peut indiquer une opération logique, comme les


rasterOP.
>> >>>(il s'agit en fait d'additionner deux DIB)
>> >>>
>> >>>Si quelqu'un a une piste,
>> >>>Nb: la solution qui consiste à envoyer les deux DIB sur le bitmap


d'un
>> >>>DC puis d'utiliser getdibits est problématique compte tenu de la
>> >>>taille
>> >>>des DIB.
>> >>>
>> >>>
>> >>>
>> >>>
>> >>> Christophe
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>
>> >>
>> >
>> >
>
>




Avatar
christophe-pasde
Re,

Les données sont des DIB: Device Independent Bitmap.

Ce que je cherche à faire c'est à partir de deux images en faire une seule.

J'ai dis un tableau d'octet car c'est la meilleur façon de le
représenter en VB. De fait il s'agit d'une zone mémoire dont je connais
taille et adresse.
de fait se que je souhaite réalisé c'est que le contenu de l'octet i
soit égal au AND logique du contenu des deux autres.

Y a pas une API qui permet de faire ça de manière globale ?

Christophe





LE TROLL a écrit :
Je n'ai pas parlé de AND, j'ai dit que:

for i = 1 to 5500
variable_string = variable_string & tableau(i)
next i

Le tableau avait à l'époque (5,5 ko * 2 ) !!!

Ça, "&" ça marche, faut tout lire quand tu lis :o)
-------------

Sinon, c'est trouble le truc, car la personne parle de 11 ko, puis de 11
Mo (ok pour l'erreur), mais moi, il me semble qu'il faudrait déjà connaître
la source des datas (elles ne se baladent pas dans l'air), ça doit être un
fichier, en en connaissant le type et la structure ça serait mieux, et ça,
la personne n'en dit mot, elle ne dit pas non plus si l'opération est
destinée à être reproduite, ou si c'est une union définitive, etc...
Pourtant ça aiderait pour décider... In fine, cette personne ne veut pas
charger en boucle (semblant dire qu'elle sait le faire?), pourtant depuis
10h30 qu'elle a posé sa question, ça fait 4h00, même en boucle, ça serait
terminé, alors tu vois ce que je veux dire, je sens pas le truc, à toi de
voir...


"Patrice Henrio" a écrit dans le message de
news:

D'une part le "&" du texte n'a rien à voir avec and
1 & 2 = 12
1 and 2 = 0

Une des slutions pour diviser par N serait de considérer le tableau comme



un

tableau d'un type de données numériques utilisant N octets et acceptant
l'opération and.
De mémoire on doit déjà pouvoir diviser par quatre en utilisant des long.



Je

n'ai pas le temps de tester mais je verrai cela plus tard.
L'autre de créer une routine en C ou en assembleur permettant un et



logique

entre deux zônes mémoires.

Je me demande même si on ne pourrait pas utiliser les routines API
d'affichage graphique. On n'arrivera pas aux 11 Mo mais on doit pouvoir
diviser au moins par Mille.

Pour la première solution supposons un tableau de 16 bytes que je



transforme

en tableau de 4 long (simplement au niveau de la lecture des données dans



un

fichier) au lieu d'une boucle de 16 passage, je n'en ai plus que 4.



"LE TROLL" <le a écrit dans le message de news:
%

Re-salut,

11 Mo, ouais, lol...

Mais déjà, ces 11 mo ils se trouvent bien quelque part à l'état
naturel,
quand tu éteins ton PC, dans un fichier je présume, alors il serait bien
de
savoir quel type de fichier et comment ils sont rangés, ce qui
déterminerait
la façon de les happer ???
----------------------


"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
message de news:415a7ef8$0$27423$

bonjour,

me suis un peu trompé de trois zéro, il s'agit de 11 Mo ( 1400*8000



octet).

ce que je veux c'est éviter de boucler sur tous les éléments du







tableau.

christophe


LE TROLL a écrit :


Heu, erreur:

t1 = t1 & x(i)

évidemment :o)


"LE TROLL" <le a écrit dans le message de
news:


Salut,

j'comprends pas tout, lol, mais bon, j'ai retenu que tu as deux



variable


indicées et que tu veux en faire une en gros (variable ou fichier,











peu

importe), de 11.000 octets (11 ko))...

Ben on peut déjà, et faute de mieux, faire:

dim i as long
dim t1 as string
'-------------------------------------------
dim t2_1(5500) as string * 1 ' ton tabelau 1
dim t2_2(5500) as string * 1 ' ton tableau 2
'---si ça ne passe pas, faire as tring (tout court), car le "* x" est



empilé


et dépilé je crois---
t1=""
for i = 1 to 5500
t1=t1 & t2_1(i)
next i
for i = 1 to 5500
t1=t1 & t2_1(i)
next i

Ensuite tu auras une chaîne, c'est mieux qu'un tableau, ça peut se







prendre

en totalité ou à une position donné (mid()), et une boucle de 11.000











ça

devrait pas mettre 20 ans...

Tu peux aussi mettre ça dans une liste additem, et plein d'atre
solution
sans doute...

Est-ce ça que tu veux ?
---------------------------


"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans











le

message de news:415a705c$0$14613$


Bonjour,

j'ai deux tableaux d'octets de dimension 1 et de taille égale.

Je souhaite faire tableau résultat = Tableaux1 and tableau 2

cad : For i&=0 to ubound(tabres): (tabres(i&)= tab1(i&) AND tab2(i&)

Les tableaux étant volumineux (11 000 octets) est-il possible
d'effectuer l'opération de manière globale, une sorte de movememory
sur
la quelle on peut indiquer une opération logique, comme les













rasterOP.

(il s'agit en fait d'additionner deux DIB)

Si quelqu'un a une piste,
Nb: la solution qui consiste à envoyer les deux DIB sur le bitmap













d'un

DC puis d'utiliser getdibits est problématique compte tenu de la
taille
des DIB.




Christophe






























Avatar
LE TROLL
Re-salut,

Pour l'API je ne sais pas...

Pour les fichiers *.dib, c'est-à-dire de type bmp codé par pixel, ce
sont normalement des fichiers, certes ils sont sur le disque je présume,
mais constituent une entité, un fichier, alors pourquoi ne pas afficher dans
des objets ces deux fichiers pour n'en faire ensuite qu'un, car s'ils se
complètent éventuellement, c'est que le second en image se place de façon
mitoyenne au premier ?

En plus, ces fichiers sont pixelisés, ils contiennent une adresse
relative de positionnement de pixel entre autre, comment sais-tu que le
second fichier va avoir des adresses de positionnement qui sont justes par
rapport au premier, qu'il n'y aura ni écrasement ni espace entre les pixels
?

Par ailleurs, et même si on connaît la structure du fichier, il faut
aussi connaître et pouvoir lire la structure de rangement de l'OS, qui peut
morceler, qui va intégrer une adresse de départ de segment, des adresses de
suite et de fin, en sus des composants du fichier lui-même, et qu'il ne
faudra pas intégrer à l'image...

En gros, tel que tu dis, tu veux que ton nouveau_fichier(octet 1) soit à fichier_1(octet 1) AND fichier_2(octet 1), les deux octets d'origine vont
fusionner en un seul, créant une image différente par chevauchement, tout à
l'heure j'avais compris que tu voulais mettre bout à bout ?

???
----------


"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
message de news:415ac4dd$0$27433$
Re,

Les données sont des DIB: Device Independent Bitmap.

Ce que je cherche à faire c'est à partir de deux images en faire une


seule.

J'ai dis un tableau d'octet car c'est la meilleur façon de le
représenter en VB. De fait il s'agit d'une zone mémoire dont je connais
taille et adresse.
de fait se que je souhaite réalisé c'est que le contenu de l'octet i
soit égal au AND logique du contenu des deux autres.

Y a pas une API qui permet de faire ça de manière globale ?

Christophe





LE TROLL a écrit :
> Je n'ai pas parlé de AND, j'ai dit que:
>
> for i = 1 to 5500
> variable_string = variable_string & tableau(i)
> next i
>
> Le tableau avait à l'époque (5,5 ko * 2 ) !!!
>
> Ça, "&" ça marche, faut tout lire quand tu lis :o)
> -------------
>
> Sinon, c'est trouble le truc, car la personne parle de 11 ko, puis


de 11
> Mo (ok pour l'erreur), mais moi, il me semble qu'il faudrait déjà


connaître
> la source des datas (elles ne se baladent pas dans l'air), ça doit être


un
> fichier, en en connaissant le type et la structure ça serait mieux, et


ça,
> la personne n'en dit mot, elle ne dit pas non plus si l'opération est
> destinée à être reproduite, ou si c'est une union définitive, etc...
> Pourtant ça aiderait pour décider... In fine, cette personne ne veut pas
> charger en boucle (semblant dire qu'elle sait le faire?), pourtant


depuis
> 10h30 qu'elle a posé sa question, ça fait 4h00, même en boucle, ça


serait
> terminé, alors tu vois ce que je veux dire, je sens pas le truc, à toi


de
> voir...
>
>
> "Patrice Henrio" a écrit dans le message de
> news:
>
>>D'une part le "&" du texte n'a rien à voir avec and
>>1 & 2 = 12
>>1 and 2 = 0
>>
>>Une des slutions pour diviser par N serait de considérer le tableau


comme
>
> un
>
>>tableau d'un type de données numériques utilisant N octets et acceptant
>>l'opération and.
>>De mémoire on doit déjà pouvoir diviser par quatre en utilisant des


long.
>
> Je
>
>>n'ai pas le temps de tester mais je verrai cela plus tard.
>>L'autre de créer une routine en C ou en assembleur permettant un et
>
> logique
>
>>entre deux zônes mémoires.
>>
>>Je me demande même si on ne pourrait pas utiliser les routines API
>>d'affichage graphique. On n'arrivera pas aux 11 Mo mais on doit pouvoir
>>diviser au moins par Mille.
>>
>>Pour la première solution supposons un tableau de 16 bytes que je
>
> transforme
>
>>en tableau de 4 long (simplement au niveau de la lecture des données


dans
>
> un
>
>>fichier) au lieu d'une boucle de 16 passage, je n'en ai plus que 4.
>>
>>
>>
>>"LE TROLL" <le a écrit dans le message de news:
>>%
>>
>>> Re-salut,
>>>
>>> 11 Mo, ouais, lol...
>>>
>>> Mais déjà, ces 11 mo ils se trouvent bien quelque part à l'état
>>>naturel,
>>>quand tu éteins ton PC, dans un fichier je présume, alors il serait


bien
>>>de
>>>savoir quel type de fichier et comment ils sont rangés, ce qui
>>>déterminerait
>>>la façon de les happer ???
>>>----------------------
>>>
>>>
>>>"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
>>>message de news:415a7ef8$0$27423$
>>>
>>>>bonjour,
>>>>
>>>>me suis un peu trompé de trois zéro, il s'agit de 11 Mo ( 1400*8000
>>>
>>>octet).
>>>
>>>>ce que je veux c'est éviter de boucler sur tous les éléments du
>
> tableau.
>
>>>>christophe
>>>>
>>>>
>>>>LE TROLL a écrit :
>>>>
>>>>
>>>>>Heu, erreur:
>>>>>
>>>>>t1 = t1 & x(i)
>>>>>
>>>>>évidemment :o)
>>>>>
>>>>>
>>>>>"LE TROLL" <le a écrit dans le message de
>>>>>news:
>>>>>
>>>>>
>>>>>> Salut,
>>>>>>
>>>>>> j'comprends pas tout, lol, mais bon, j'ai retenu que tu as deux
>>>>>
>>>>>variable
>>>>>
>>>>>
>>>>>>indicées et que tu veux en faire une en gros (variable ou fichier,
>
> peu
>
>>>>>>importe), de 11.000 octets (11 ko))...
>>>>>>
>>>>>> Ben on peut déjà, et faute de mieux, faire:
>>>>>>
>>>>>>dim i as long
>>>>>>dim t1 as string
>>>>>>'-------------------------------------------
>>>>>>dim t2_1(5500) as string * 1 ' ton tabelau 1
>>>>>>dim t2_2(5500) as string * 1 ' ton tableau 2
>>>>>>'---si ça ne passe pas, faire as tring (tout court), car le "* x"


est
>>>>>
>>>>>empilé
>>>>>
>>>>>
>>>>>>et dépilé je crois---
>>>>>>t1=""
>>>>>>for i = 1 to 5500
>>>>>>t1=t1 & t2_1(i)
>>>>>>next i
>>>>>>for i = 1 to 5500
>>>>>>t1=t1 & t2_1(i)
>>>>>>next i
>>>>>>
>>>>>>Ensuite tu auras une chaîne, c'est mieux qu'un tableau, ça peut se
>>>
>>>prendre
>>>
>>>>>>en totalité ou à une position donné (mid()), et une boucle de 11.000
>
> ça
>
>>>>>>devrait pas mettre 20 ans...
>>>>>>
>>>>>>Tu peux aussi mettre ça dans une liste additem, et plein d'atre
>>>>>>solution
>>>>>>sans doute...
>>>>>>
>>>>>>Est-ce ça que tu veux ?
>>>>>>---------------------------
>>>>>>
>>>>>>
>>>>>>"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans
>
> le
>
>>>>>>message de news:415a705c$0$14613$
>>>>>>
>>>>>>
>>>>>>>Bonjour,
>>>>>>>
>>>>>>>j'ai deux tableaux d'octets de dimension 1 et de taille égale.
>>>>>>>
>>>>>>>Je souhaite faire tableau résultat = Tableaux1 and tableau 2
>>>>>>>
>>>>>>>cad : For i&=0 to ubound(tabres): (tabres(i&)= tab1(i&) AND


tab2(i&)
>>>>>>>
>>>>>>>Les tableaux étant volumineux (11 000 octets) est-il possible
>>>>>>>d'effectuer l'opération de manière globale, une sorte de movememory
>>>>>>>sur
>>>>>>>la quelle on peut indiquer une opération logique, comme les
>
> rasterOP.
>
>>>>>>>(il s'agit en fait d'additionner deux DIB)
>>>>>>>
>>>>>>>Si quelqu'un a une piste,
>>>>>>>Nb: la solution qui consiste à envoyer les deux DIB sur le bitmap
>
> d'un
>
>>>>>>>DC puis d'utiliser getdibits est problématique compte tenu de la
>>>>>>>taille
>>>>>>>des DIB.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Christophe
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>
>>
>
>


Avatar
Patrice Henrio
De mémoire et sans vérifier je crois qu'il existe une API qui permet de
faire un et logique entre deux images ou dexu emplacements mémoires de même
taille. je n'en sais pas plus mais je chercherai de ce côté.

"LE TROLL" <le a écrit dans le message de news:

Re-salut,

Pour l'API je ne sais pas...

Pour les fichiers *.dib, c'est-à-dire de type bmp codé par pixel, ce
sont normalement des fichiers, certes ils sont sur le disque je présume,
mais constituent une entité, un fichier, alors pourquoi ne pas afficher
dans
des objets ces deux fichiers pour n'en faire ensuite qu'un, car s'ils se
complètent éventuellement, c'est que le second en image se place de façon
mitoyenne au premier ?

En plus, ces fichiers sont pixelisés, ils contiennent une adresse
relative de positionnement de pixel entre autre, comment sais-tu que le
second fichier va avoir des adresses de positionnement qui sont justes par
rapport au premier, qu'il n'y aura ni écrasement ni espace entre les
pixels
?

Par ailleurs, et même si on connaît la structure du fichier, il faut
aussi connaître et pouvoir lire la structure de rangement de l'OS, qui
peut
morceler, qui va intégrer une adresse de départ de segment, des adresses
de
suite et de fin, en sus des composants du fichier lui-même, et qu'il ne
faudra pas intégrer à l'image...

En gros, tel que tu dis, tu veux que ton nouveau_fichier(octet 1) soit
> à fichier_1(octet 1) AND fichier_2(octet 1), les deux octets d'origine
vont
fusionner en un seul, créant une image différente par chevauchement, tout
à
l'heure j'avais compris que tu voulais mettre bout à bout ?

???
----------


"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
message de news:415ac4dd$0$27433$
Re,

Les données sont des DIB: Device Independent Bitmap.

Ce que je cherche à faire c'est à partir de deux images en faire une


seule.

J'ai dis un tableau d'octet car c'est la meilleur façon de le
représenter en VB. De fait il s'agit d'une zone mémoire dont je connais
taille et adresse.
de fait se que je souhaite réalisé c'est que le contenu de l'octet i
soit égal au AND logique du contenu des deux autres.

Y a pas une API qui permet de faire ça de manière globale ?

Christophe





LE TROLL a écrit :
> Je n'ai pas parlé de AND, j'ai dit que:
>
> for i = 1 to 5500
> variable_string = variable_string & tableau(i)
> next i
>
> Le tableau avait à l'époque (5,5 ko * 2 ) !!!
>
> Ça, "&" ça marche, faut tout lire quand tu lis :o)
> -------------
>
> Sinon, c'est trouble le truc, car la personne parle de 11 ko, puis


de 11
> Mo (ok pour l'erreur), mais moi, il me semble qu'il faudrait déjà


connaître
> la source des datas (elles ne se baladent pas dans l'air), ça doit être


un
> fichier, en en connaissant le type et la structure ça serait mieux, et


ça,
> la personne n'en dit mot, elle ne dit pas non plus si l'opération est
> destinée à être reproduite, ou si c'est une union définitive, etc...
> Pourtant ça aiderait pour décider... In fine, cette personne ne veut
> pas
> charger en boucle (semblant dire qu'elle sait le faire?), pourtant


depuis
> 10h30 qu'elle a posé sa question, ça fait 4h00, même en boucle, ça


serait
> terminé, alors tu vois ce que je veux dire, je sens pas le truc, à toi


de
> voir...
>
>
> "Patrice Henrio" a écrit dans le message
> de
> news:
>
>>D'une part le "&" du texte n'a rien à voir avec and
>>1 & 2 = 12
>>1 and 2 = 0
>>
>>Une des slutions pour diviser par N serait de considérer le tableau


comme
>
> un
>
>>tableau d'un type de données numériques utilisant N octets et acceptant
>>l'opération and.
>>De mémoire on doit déjà pouvoir diviser par quatre en utilisant des


long.
>
> Je
>
>>n'ai pas le temps de tester mais je verrai cela plus tard.
>>L'autre de créer une routine en C ou en assembleur permettant un et
>
> logique
>
>>entre deux zônes mémoires.
>>
>>Je me demande même si on ne pourrait pas utiliser les routines API
>>d'affichage graphique. On n'arrivera pas aux 11 Mo mais on doit pouvoir
>>diviser au moins par Mille.
>>
>>Pour la première solution supposons un tableau de 16 bytes que je
>
> transforme
>
>>en tableau de 4 long (simplement au niveau de la lecture des données


dans
>
> un
>
>>fichier) au lieu d'une boucle de 16 passage, je n'en ai plus que 4.
>>
>>
>>
>>"LE TROLL" <le a écrit dans le message de news:
>>%
>>
>>> Re-salut,
>>>
>>> 11 Mo, ouais, lol...
>>>
>>> Mais déjà, ces 11 mo ils se trouvent bien quelque part à l'état
>>>naturel,
>>>quand tu éteins ton PC, dans un fichier je présume, alors il serait


bien
>>>de
>>>savoir quel type de fichier et comment ils sont rangés, ce qui
>>>déterminerait
>>>la façon de les happer ???
>>>----------------------
>>>
>>>
>>>"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans le
>>>message de news:415a7ef8$0$27423$
>>>
>>>>bonjour,
>>>>
>>>>me suis un peu trompé de trois zéro, il s'agit de 11 Mo ( 1400*8000
>>>
>>>octet).
>>>
>>>>ce que je veux c'est éviter de boucler sur tous les éléments du
>
> tableau.
>
>>>>christophe
>>>>
>>>>
>>>>LE TROLL a écrit :
>>>>
>>>>
>>>>>Heu, erreur:
>>>>>
>>>>>t1 = t1 & x(i)
>>>>>
>>>>>évidemment :o)
>>>>>
>>>>>
>>>>>"LE TROLL" <le a écrit dans le message de
>>>>>news:
>>>>>
>>>>>
>>>>>> Salut,
>>>>>>
>>>>>> j'comprends pas tout, lol, mais bon, j'ai retenu que tu as deux
>>>>>
>>>>>variable
>>>>>
>>>>>
>>>>>>indicées et que tu veux en faire une en gros (variable ou fichier,
>
> peu
>
>>>>>>importe), de 11.000 octets (11 ko))...
>>>>>>
>>>>>> Ben on peut déjà, et faute de mieux, faire:
>>>>>>
>>>>>>dim i as long
>>>>>>dim t1 as string
>>>>>>'-------------------------------------------
>>>>>>dim t2_1(5500) as string * 1 ' ton tabelau 1
>>>>>>dim t2_2(5500) as string * 1 ' ton tableau 2
>>>>>>'---si ça ne passe pas, faire as tring (tout court), car le "* x"


est
>>>>>
>>>>>empilé
>>>>>
>>>>>
>>>>>>et dépilé je crois---
>>>>>>t1=""
>>>>>>for i = 1 to 5500
>>>>>>t1=t1 & t2_1(i)
>>>>>>next i
>>>>>>for i = 1 to 5500
>>>>>>t1=t1 & t2_1(i)
>>>>>>next i
>>>>>>
>>>>>>Ensuite tu auras une chaîne, c'est mieux qu'un tableau, ça peut se
>>>
>>>prendre
>>>
>>>>>>en totalité ou à une position donné (mid()), et une boucle de
>>>>>>11.000
>
> ça
>
>>>>>>devrait pas mettre 20 ans...
>>>>>>
>>>>>>Tu peux aussi mettre ça dans une liste additem, et plein d'atre
>>>>>>solution
>>>>>>sans doute...
>>>>>>
>>>>>>Est-ce ça que tu veux ?
>>>>>>---------------------------
>>>>>>
>>>>>>
>>>>>>"christophe-pasde<> @wanadoo.fr>" <"christophe-pasde<> a écrit dans
>
> le
>
>>>>>>message de news:415a705c$0$14613$
>>>>>>
>>>>>>
>>>>>>>Bonjour,
>>>>>>>
>>>>>>>j'ai deux tableaux d'octets de dimension 1 et de taille égale.
>>>>>>>
>>>>>>>Je souhaite faire tableau résultat = Tableaux1 and tableau 2
>>>>>>>
>>>>>>>cad : For i&=0 to ubound(tabres): (tabres(i&)= tab1(i&) AND


tab2(i&)
>>>>>>>
>>>>>>>Les tableaux étant volumineux (11 000 octets) est-il possible
>>>>>>>d'effectuer l'opération de manière globale, une sorte de
>>>>>>>movememory
>>>>>>>sur
>>>>>>>la quelle on peut indiquer une opération logique, comme les
>
> rasterOP.
>
>>>>>>>(il s'agit en fait d'additionner deux DIB)
>>>>>>>
>>>>>>>Si quelqu'un a une piste,
>>>>>>>Nb: la solution qui consiste à envoyer les deux DIB sur le bitmap
>
> d'un
>
>>>>>>>DC puis d'utiliser getdibits est problématique compte tenu de la
>>>>>>>taille
>>>>>>>des DIB.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Christophe
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>
>>
>
>