domanda di controllo Firma OpenNETCF

Question

Sto usando il controllo della firma in OpenNETCF. E le grandi opere per la maggior parte hanno bisogno di tutto io.

Tuttavia, ho bisogno di un modo invertito la firma e caricare nuovamente.

E 'una chiamata per ottenere il "byte" per la firma (GetSignatureEx()). Esso restituisce un byte[] della firma. Questa firma può essere caricata di nuovo con LoadSignatureEx().

Non riesco a capire il sistema di questi byte. Ho pensato che potrebbero essere coordinate, ma non sembra così ora.

Se qualcuno là fuori sa un modo per invertire la firma e caricarlo nuovamente, sarei grato a sentirlo.

---

Nota per gli altri che potrebbero cura:

Questi byte sembrano avere la struttura seguente (in ordine):

2 bytes to show Width  
2 bytes to show Height  
  -- This next part repeats till the end of the array  
  2 bytes to show How many points are in the next line  
    -- This next part repeats as many times as the previous line indicated  
    1 byte for the x coordinate of the point  
    1 byte for the y coordinate of the point  
    2 bytes for the width of the pen (I am not 100% sure on this one)  

Io posto il mio codice finale una volta che ho fatto.

---

In seguito Nota: Ok, dopo tonnellate di lavoro, ho trovato quanto facile è quello di capovolgere la vista utilizzando il costruito nel roba (grazie MusiGenesis). Che sembra essere molto meno errore di processo di un soggetto a me.

Nel caso in cui qualcun altro lo vuole, ecco la mia non finito del codice. (Io ero vicino, ma la roba per passare alla successiva "linea" non funziona perfettamente ragione.) (EDIT:.. Ho deciso che mi è piaciuto il modo in cui questo ha funzionato un po 'più Ho aggiornato il codice qui sotto Si funzionerà fino a quando la larghezza o l'altezza del controllo Firma non è maggiore di 256. (risposta di See ctacke sotto).)

Ma prima, grande grazie a MusiGenesis che mi hanno aiutato a capire tutto questo. Sei molto disponibile e mi apprezzare i vostri sforzi a lot!

Ora il codice:

private void InvertSignature(ref byte[] original)
{
    int currentIndex = 0;
    short width = BitConverter.ToInt16(original, 0);
    short height = BitConverter.ToInt16(original, 2);
    while (currentIndex < original.Length - 4)
    {
        // Move past the last iteration (or the width and hight for the first time through).
        currentIndex += 4;
        // Find the length of the next segment.
        short nextGroup = BitConverter.ToInt16(original, currentIndex);
        //Advance one so we get past the 2 byte group
        currentIndex += 2;
        // Find the actual index of the last set of coordinates for this segment.
        int nextNumberOfItems = ((nextGroup) * 4) + currentIndex;
        // Invert the coordinates
        for (int i = currentIndex; i < (nextNumberOfItems - 1); i += 4)
        {
            currentIndex = i;

            //Invert Horizontal
            int newHorzPoint = width - original[i] - 1;
            if (newHorzPoint <= 0)
                newHorzPoint = 0;
            else if (newHorzPoint >= width - 1)
                newHorzPoint = width - 1;
            original[i] = (byte)newHorzPoint;

            // Invert Vertical
            int newVertPoint = height - original[i + 1] - 1;
            if (newVertPoint <= 0)
                newVertPoint = 0;
            else if (newVertPoint >= height - 1)
                newVertPoint = height - 1;
            original[i + 1] = (byte)newVertPoint;
        }
    }
}

Answer 1

Completamente-testata-code Golf:

public void InvertSignature(ref byte[] original, 
    bool invertHorizontal, bool invertVertical)
{
    for (int i = 0; i < original.Length; i += 2)
    {
        if ((original[i] != 0) && (original[i + 1] != 0))
        {
            if (invertHorizontal)
            {
                original[i] = 232 - original[i] - 1;
            }
            if (invertVertical)
            {
                original[i + 1] = 64 - original[i + 1] - 1;
            }
        }
    }
}

Oppure provate questa versione, sul presupposto che i primi 4 byte sono utilizzati per memorizzare la larghezza e l'altezza della firma (2 byte brevi interi per ciascuno):

public void InvertSignature(ref byte[] original, 
    bool invertHorizontal, bool invertVertical)
{
    byte w = (byte)BitConverter.ToInt16(original, 0) - 1;
    byte h = (byte)BitConverter.ToInt16(original, 2) - 1;
    // TO DO: blow up if w or h are > 255
    for (int i = 4; i < original.Length; i += 2)
    {
        if ((original[i] != 0) && (original[i + 1] != 0))
        {
            if (invertHorizontal)
            {
                original[i] = w - original[i];
            }
            if (invertVertical)
            {
                original[i + 1] = h - original[i + 1];
            }
        }
    }
}

See: Conversione OpenNETCF GetSignatureEx al bitmap sul desktop

Aggiornamento: Data la tua descrizione del motivo per cui è necessario invertire la firma, potrebbe essere più facile per voi solo invertito la screenOrientation del dispositivo di 180 gradi (e poi di nuovo dopo le indicazioni del cliente) . In questo modo si potrebbe anche avere etichette che dire al cliente che cosa sono firma -. Altrimenti che stanno andando a guardare un po 'di testa in giù roba (diverso da quello di controllo firma stessa)

Per fare questo, aggiungere un riferimento a Microsoft.WindowsCE.Forms al progetto, quindi aggiungere using Microsoft.WindowsCE.Forms; alla parte superiore del file.

Per invertire lo schermo di 180 gradi:

SystemSettings.ScreenOrientation = ScreenOrientation.Angle180;

Per impostare di nuovo al normale:

SystemSettings.ScreenOrientation = ScreenOrientation.Angle0;

Se si esegue questo nell'emulatore, lo schermo verrà comunque visualizzato normalmente in posizione verticale, ma la pelle viene capovolto a testa in giù.

Aggiornamento: un ultimo colpo a questo, in base alla risposta del ctacke (questo dovrebbe funzionare per le firme con qualsiasi dimensione):

public void InvertSignature(ref byte[] original, 
    bool invertHorizontal, bool invertVertical)
{
    short w = BitConverter.ToInt16(original, 0);
    short h = BitConverter.ToInt16(original, 2);
    int i = 4;
    while (i < original.Length)
    {
        if (invertHorizontal)
        {
            if (w < 256)
            {
                if (original[i] != 0)
                {
                    original[i] = (byte)w - original[i] - 1;
                }
                i++;
            }
            else
            {
                short val = BitConverter.ToInt16(original, i);
                if (val != 0)
                {
                    val = w - val - 1;
                    byte[] valbytes = BitConverter.GetBytes(val);
                    Buffer.BlockCopy(valbytes, 0, original, i, 2);
                }
                i += 2;
            }
        }
        else
        {
            i += (w < 256) ? 1 : 2;
        }
        if (invertVertical)
        {
            if (h < 256)
            {
                if (original[i] != 0)
                {
                    original[i] = (byte)h - original[i] - 1;
                }
                i++;
            }
            else
            {
                short val = BitConverter.ToInt16(original, i);
                if (val != 0)
                {
                    val = h - val - 1;
                    byte[] valbytes = BitConverter.GetBytes(val);
                    Buffer.BlockCopy(valbytes, 0, original, i, 2);
                }
                i += 2;
            }
        }
        else
        {
            i += (h < 256) ? 1 : 2;
        }
    }
}

Answer 2

I potrebbe essere un po 'in ritardo, ma sto guardando il codice in questo momento e qui ci sono alcuni punti degni di nota.

• I primi 2 byte sono la larghezza.
• I successivi 2 byte sono l'altezza.
• Il resto dei dati sono coordinate X, Y, tuttavia il formato di memorizzazione è ingannevole e può cambiare. Se la dimensione (x o y) è <256, usiamo un byte per memorizzare il valore. Se è maggiore, usiamo 2 byte. Questo significa che si potrebbe vedere valli memorizzati come XYXY, XXYXXY o XYYXYY.