Obtenez quatre numéros de 16bit d'une valeur hexadécimale 64bit

Question

Je suis passé par ces questions connexes:

• How to convert numbers between hexadecimal and decimal in C#?
• How to Convert 64bit Long Data Type to 16bit Data Type
• Way to get value of this hex number

Mais je ne l'ai pas eu de réponse probablement parce que Je ne comprends pas les valeurs 64 bits ou 16 bits.

J'avais posté une question sur Picasa et la détection de visage, pour utiliser la détection de visage que Picasa fait pour obtenir des photos individuelles à partir d'une photo contenant de nombreuses images. Automatic Face detection using API

Dans an answer@Joel Martinez liée à une réponse sur laquelle ledit picasa help:

Le nombre enfermé dans rect64() est un nombre hexadécimal 64 bits.

• Brisez cela en quatre nombres de 16 bits.
• Diviser chaque par le nombre maximal de 16 bits non signé (65535) et vous aurez quatre nombres compris entre 0 et 1.

le texte intégral

@oedious a écrit: - Cela va être un peu technique, alors accrochez-vous. * Le numéro encapsulé dans rect64() est un nombre hexadécimal 64 bits. * Brisez cela en quatre nombres de 16 bits. * Diviser chacun par le 16 bits au maximum non signé numéro (65535) et vous aurez quatre nombres compris entre 0 et 1. * Les quatre numéros restants vous donnent relativement des coordonnées du rectangle de visage: (gauche, haut , droite, bas). * Si vous voulez se retrouver avec coordonnées absolues, plusieurs à gauche et juste à côté de la largeur de l'image et le haut et en bas de la hauteur de l'image.

Un exemple de fichier picasa.ini:

[1.jpg] 
backuphash=65527 
faces=rect64(5520c092dfb2f8d),615eec1bb18bdec5;rect64(dcc2ccf1fd63e93e),bc209d92a3388dc3;rect64(52524b7c785e6cf6),242908faa5044cb3 
crop=rect64(0) 

Comment puis-je obtenir les 4 chiffres de l'hexagone 64 bits?

Je suis désolé, je ne comprends pas les réponses. Je suppose que je vais devoir apprendre du C++ (je suis un développeur Web Java avec des faiblesses en mathématiques) avant de pouvoir écrire et écrire quelque chose qui découpera une image en plusieurs images avec l'aide de quelques coordonnées. Je suis à la recherche dans CodeLab et creating plugins for Paint.net trop

Answer 1

Voici l'algorithme:.

Le reste de la division par 0x10000 (65536) vous donnera le premier numéro. Prenez le résultat, puis divisez par 0x10000 (65536) à nouveau, le reste vous donnera le deuxième nombre.

Prenez le résultat le diviser par 0x10000 (65536) à nouveau, le reste vous donnera le troisième nombre.

Le résultat est le quatrième nombre.

Answer 2

Cela dépend de votre langage de programmation - en C# dire que vous pouvez utiliser la classe BitConverter, ce qui vous permet d'extraire un numéro en fonction de la position d'octet dans un tableau d'octets.

UInt64 largeHexNumber = 420404334; 
byte[] hexData = BitConverter.GetBytes(largeHexNumber); 
UInt16 firstValue = BitConverter.ToUInt16(hexData, 0); 
UInt16 secondValue = BitConverter.ToUInt16(hexData, 2); 
UInt16 thirdValue = BitConverter.ToUInt16(hexData, 4); 
UInt16 forthValue = BitConverter.ToUInt16(hexData, 6); 

Answer 3

Cela dépend de la langue. Pour le C-famille des langues, il peut être fait comme celui-ci (en C#):

UInt64 number  = 0x4444333322221111; 

//to get the ones, use a mask 
//     0x4444333322221111 
const UInt64 mask1 =    0xFFFF; 
UInt16 part1 = (UInt16)(number & mask1); 

//to get the twos, use a mask then shift 
//     0x4444333322221111 
const UInt64 mask2 =   0xFFFF0000; 
UInt16 part2 = (UInt16)((number & mask2) >> 16); 

//etc. 
//     0x4444333322221111 
const UInt64 mask3 =  0xFFFF00000000; 
UInt16 part3 = (UInt16)((number & mask3) >> 32); 

//     0x4444333322221111 
const UInt64 mask4 = 0xFFFF000000000000; 
UInt16 part4 = (UInt16)((number & mask4) >> 48); 

Answer 4

Ce que je pense que l'on vous demande de faire est de prendre les 64 bits de données que vous avez et de le traiter comme 4 16 entiers bit-bit. De là, vous prenez les valeurs de 16 bits et les convertissez en pourcentages. Ces pourcentages, multipliés par la hauteur/largeur de l'image, vous donnent 4 coordonnées.

Comment vous faites cela dépend de la langue que vous la programmation dans

Answer 5

Si vous voulez bases, que vous avez ce nombre hexadécimal:

Nous séparons dans vos 4 parties sur papier, donc tout ce qui reste est de les extraire. Cela implique d'utiliser un masque ffff pour bloquer tout le reste sauf notre numéro (f ne masque rien, 0 masque tout) et de le glisser sur chaque partie. Nous avons donc:

part 1: 4444333322221111 & ffff    = 1111 
part 2: 4444333322221111 & ffff0000   = 22220000 
part 3: 4444333322221111 & ffff00000000  = 333300000000 
part 4: 4444333322221111 & ffff000000000000 = 4444000000000000 

Tout ce qui reste est de supprimer les 0 est à la fin. Dans l'ensemble, en C, vous pouvez écrire ce que:

int GetPart(int64 pack, int n) // where you define int64 as whatever your platform uses 
{        // __int64 in msvc 
    return (pack & (0xffff << (16*n)) >> (16*n); 
} 

Donc, fondamentalement, vous calculez le masque 0xffff (2 octets) déplacé vers la droite 16 * n bits (0 pour le premier, 16 pour le 2ème, 32 pour le 3ème et 48 pour le 4ème), appliquez-le sur le nombre pour masquer tout sauf la partie qui nous intéresse, puis décalez le résultat 16 * n bits pour effacer ces 0 à la fin.

Lecture supplémentaire: Bitwise operators in C.

Espérons que ça aide!

Answer 6

J'avais besoin de convertir les valeurs crop = rect64() du fichier picasa.ini. J'ai créé la méthode ruby ​​suivante avec les informations ci-dessus.

def coordinates(hex_num) 
[ 
    hex_num.divmod(65536)[1], 
    hex_num.divmod(65536)[0].divmod(65536)[1], 
    hex_num.divmod(65536)[0].divmod(65536)[0].divmod(65536)[1], 
    hex_num.divmod(65536)[0].divmod(65536)[0].divmod(65536)[0].divmod(65536)[1] 
].reverse 
end 

Cela fonctionne, mais j'avais besoin d'ajouter la méthode .reverse sur la matrice pour obtenir le résultat souhaité.