Пример #1
0
        public void EqualsTest()
        {
            var data = new Int16[, ] {
                { 0, 0 }, { -1, -1 }, { 1, 1 }
            };
            var length = data.GetLength(0);

            for (var i = 0; i < length; i++)
            {
                InteropByte interopByte  = data[i, 0];
                InteropByte interopByte2 = data[i, 1];
                Assert.IsTrue(interopByte.Equals(interopByte2));
            }
        }
Пример #2
0
    public Boolean runTest()
    {
        Console.Error.WriteLine(s_strTFPath + " " + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
        int    iCountErrors    = 0;
        int    iCountTestcases = 0;
        String strLoc          = "Loc_000oo";
        String strBaseLoc;

        short[]   in2Arr  = new Int16[10];
        int[]     in4Arr  = new Int32[5];
        long[]    in8Arr  = new Int64[0];
        String[]  strArr  = new String[6];
        Boolean[] boArr   = new Boolean[3];
        Double[]  dblArr  = new Double[2];
        Single[]  snglArr = new Single[32000];
        Char[]    chArr   = new Char[10000];
        int       rank;

        try {
LABEL_860_GENERAL:
            do
            {
                strLoc = "Loc_819yt";
                rank   = -1;
                in2Arr = new Int16[5];
                iCountTestcases++;
                try {
                    in2Arr.GetLength(rank);
                    iCountErrors++;
                    Console.WriteLine(s_strTFAbbrev + "Err_499ws! , GetLength==" + in2Arr.Length);
                } catch (IndexOutOfRangeException ioorExc) {}
                catch (Exception exc) {
                    iCountErrors++;
                    Console.WriteLine(s_strTFAbbrev + "Err_758! exc==" + exc);
                }
                strLoc = "Loc_819ee";
                rank   = 1;
                in2Arr = new Int16[5];
                iCountTestcases++;
                try {
                    in2Arr.GetLength(rank);
                    iCountErrors++;
                    Console.WriteLine(s_strTFAbbrev + "Err_500ws! , GetLength==" + in2Arr.Length);
                } catch (IndexOutOfRangeException ioorExc) {}
                catch (Exception exc) {
                    iCountErrors++;
                    Console.WriteLine(s_strTFAbbrev + "Err_750! exc==" + exc);
                }
                strLoc = "Loc_482wu";
                rank   = 0;
                in2Arr = new Int16[10];
                iCountTestcases++;
                if (in2Arr.GetLength(rank) != 10)
                {
                    iCountErrors++;
                    Console.WriteLine(s_strTFAbbrev + "Err_481ua! , GetLength==" + in2Arr.Length);
                }
                strLoc = "Loc_471ay";
                in4Arr = new Int32[5];
                iCountTestcases++;
                if (in4Arr.GetLength(rank) != 5)
                {
                    iCountErrors++;
                    Console.WriteLine(s_strTFAbbrev + "Err_29qaq! , GetLength==" + in4Arr.Length);
                }
                strLoc = "Loc_982uq";
                in8Arr = new Int64[0];
                iCountTestcases++;
                if (in8Arr.GetLength(rank) != 0)
                {
                    iCountErrors++;
                    Console.WriteLine(s_strTFAbbrev + "Err_237sy! , GetLength==" + in8Arr.Length);
                }
                strLoc = "Loc_172ms";
                boArr  = new Boolean[3];
                iCountTestcases++;
                if (boArr.GetLength(rank) != 3)
                {
                    iCountErrors++;
                    Console.WriteLine(s_strTFAbbrev + "Err_382! , GetLength==" + boArr.Length);
                }
                strLoc = "Loc_49su";
                dblArr = new Double[2];
                iCountTestcases++;
                if (dblArr.GetLength(rank) != 2)
                {
                    iCountErrors++;
                    Console.WriteLine(s_strTFAbbrev + "Err_200su! , GetLength==" + dblArr.Length);
                }
                strLoc  = "Loc_371su";
                snglArr = new Single[32000];
                iCountTestcases++;
                if (snglArr.GetLength(rank) != 32000)
                {
                    iCountErrors++;
                    Console.WriteLine(s_strTFAbbrev + "Err_319aw! , GetLength==" + snglArr.Length);
                }
                strLoc    = "Loc_129wi";
                strArr    = new String[5];
                strArr[2] = null;
                iCountTestcases++;
                if (strArr.GetLength(rank) != 5)
                {
                    iCountErrors++;
                    Console.WriteLine(s_strTFAbbrev + "Err_71ahw! , GetLength==" + strArr.Length);
                }
            } while (false);
        } catch (Exception exc_general) {
            ++iCountErrors;
            Console.WriteLine(s_strTFAbbrev + " Error Err_8888yyy!  strLoc==" + strLoc + ", exc_general==" + exc_general);
        }
        if (iCountErrors == 0)
        {
            return(true);
        }
        else
        {
            return(false);
        }
    }
Пример #3
0
        /// <summary>
        /// Alpaca Extension - Convert a byte array to a 2D or 3D mage array based on the array metadata.
        /// </summary>
        /// <param name="imageBytes">byte array to convert</param>
        /// <returns>2D or 3D array as specified in the array metadata.</returns>
        /// <exception cref="InvalidValueException">The byte array is null.</exception>
        public static Array ToImageArray(this byte[] imageBytes)
        {
            ImageArrayElementTypes imageElementType;
            ImageArrayElementTypes transmissionElementType;
            int rank;
            int dimension1;
            int dimension2;
            int dimension3;
            int dataStart;

            // Validate the incoming array
            if (imageBytes is null)
            {
                throw new InvalidValueException("ToImageArray - Supplied array is null.");
            }
            if (imageBytes.Length <= ARRAY_METADATAV1_LENGTH)
            {
                throw new InvalidValueException($"ToImageArray - Supplied array does not exceed the size of the mandatory metadata. Arrays must contain at least {ARRAY_METADATAV1_LENGTH} bytes. The supplied array has a length of {imageBytes.Length}.");
            }

            int metadataVersion = imageBytes.GetMetadataVersion();

            // Get the metadata version and extract the supplied values
            switch (metadataVersion)
            {
            case 1:
                ArrayMetadataV1 metadataV1 = imageBytes.GetMetadataV1();
                // Set the array type, rank and dimensions
                imageElementType        = metadataV1.ImageElementType;
                transmissionElementType = metadataV1.TransmissionElementType;
                rank       = metadataV1.Rank;
                dimension1 = metadataV1.Dimension1;
                dimension2 = metadataV1.Dimension2;
                dimension3 = metadataV1.Dimension3;
                dataStart  = metadataV1.DataStart;

                Debug.WriteLine($"ToImageArray - Element type: {imageElementType} Transmission type: {transmissionElementType}");

                break;

            default:
                throw new InvalidValueException($"ToImageArray - The supplied array contains an unsupported metadata version number: {metadataVersion}. This component supports metadata version 1.");
            }

            // Validate the metadata
            if (imageElementType == ImageArrayElementTypes.Unknown)
            {
                throw new InvalidValueException("ToImageArray - ImageArrayElementType is 0, meaning ImageArrayElementTypes.Unknown");
            }
            if (imageElementType > Enum.GetValues(typeof(ImageArrayElementTypes)).Cast <ImageArrayElementTypes>().Max())
            {
                throw new InvalidValueException($"ToImageArray - The ImageArrayElementType value {((int)imageElementType)} is outside the valid range 0 to {Enum.GetValues(typeof(ImageArrayElementTypes)).Cast<ImageArrayElementTypes>().Max()}");
            }
            if (transmissionElementType == ImageArrayElementTypes.Unknown)
            {
                throw new InvalidValueException("ToImageArray - The TransmissionElementType is 0, meaning ImageArrayElementTypes.Unknown");
            }

            // Convert the returned byte[] into the form that the client is expecting
            if ((imageElementType == ImageArrayElementTypes.Int32) & (transmissionElementType == ImageArrayElementTypes.Int16)) // Handle the special case where Int32 has been converted to Int16 for transmission
            {
                switch (rank)
                {
                case 2:     // Rank 2
                    Int16[,] short2dArray = new Int16[dimension1, dimension2];
                    Buffer.BlockCopy(imageBytes, dataStart, short2dArray, 0, imageBytes.Length - dataStart);

                    int[,] int2dArray = new int[dimension1, dimension2];
                    Parallel.For(0, short2dArray.GetLength(0), (i) =>
                    {
                        for (int j = 0; j < short2dArray.GetLength(1); j++)
                        {
                            int2dArray[i, j] = short2dArray[i, j];
                        }
                    });
                    return(int2dArray);

                case 3:     // Rank 3
                    Int16[,,] short3dArray = new Int16[dimension1, dimension2, dimension3];
                    Buffer.BlockCopy(imageBytes, dataStart, short3dArray, 0, imageBytes.Length - dataStart);

                    int[,,] int3dArray = new int[dimension1, dimension2, dimension3];
                    Parallel.For(0, short3dArray.GetLength(0), (i) =>
                    {
                        for (int j = 0; j < short3dArray.GetLength(1); j++)
                        {
                            for (int k = 0; k < short3dArray.GetLength(2); k++)
                            {
                                int3dArray[i, j, k] = short3dArray[i, j, k];
                            }
                        }
                    });
                    return(int3dArray);

                default:
                    throw new InvalidValueException($"ToImageArray - Returned array cannot be handled because it does not have a rank of 2 or 3. Returned array rank:{rank}.");
                }
            }
            else if ((imageElementType == ImageArrayElementTypes.Int32) & (transmissionElementType == ImageArrayElementTypes.UInt16)) // Handle the special case where Int32 values has been converted to UInt16 for transmission
            {
                switch (rank)
                {
                case 2:     // Rank 2
                    UInt16[,] uInt16Array2D = new UInt16[dimension1, dimension2];
                    Buffer.BlockCopy(imageBytes, dataStart, uInt16Array2D, 0, imageBytes.Length - dataStart);

                    int[,] int2dArray = new int[dimension1, dimension2];
                    Parallel.For(0, uInt16Array2D.GetLength(0), (i) =>
                    {
                        for (int j = 0; j < uInt16Array2D.GetLength(1); j++)
                        {
                            int2dArray[i, j] = uInt16Array2D[i, j];
                        }
                    });
                    return(int2dArray);

                case 3:     // Rank 3
                    UInt16[,,] uInt16Array3D = new UInt16[dimension1, dimension2, dimension3];
                    Buffer.BlockCopy(imageBytes, dataStart, uInt16Array3D, 0, imageBytes.Length - dataStart);

                    int[,,] int3dArray = new int[dimension1, dimension2, dimension3];
                    Parallel.For(0, uInt16Array3D.GetLength(0), (i) =>
                    {
                        for (int j = 0; j < uInt16Array3D.GetLength(1); j++)
                        {
                            for (int k = 0; k < uInt16Array3D.GetLength(2); k++)
                            {
                                int3dArray[i, j, k] = uInt16Array3D[i, j, k];
                            }
                        }
                    });
                    return(int3dArray);

                default:
                    throw new InvalidValueException($"ToImageArray - Returned array cannot be handled because it does not have a rank of 2 or 3. Returned array rank:{rank}.");
                }
            }
            else // Handle all other cases where the expected array type and the transmitted array type are the same
            {
                if (imageElementType == transmissionElementType) // Required and transmitted array element types are the same
                {
                    switch (imageElementType)
                    {
                    case ImageArrayElementTypes.Byte:
                        switch (rank)
                        {
                        case 2:         // Rank 2
                            byte[,] byte2dArray = new byte[dimension1, dimension2];
                            Buffer.BlockCopy(imageBytes, dataStart, byte2dArray, 0, imageBytes.Length - dataStart);
                            return(byte2dArray);

                        case 3:         // Rank 3
                            byte[,,] byte3dArray = new byte[dimension1, dimension2, dimension3];
                            Buffer.BlockCopy(imageBytes, dataStart, byte3dArray, 0, imageBytes.Length - dataStart);
                            return(byte3dArray);

                        default:
                            throw new InvalidValueException($"ToImageArray - Returned byte array cannot be handled because it does not have a rank of 2 or 3. Returned array rank:{rank}.");
                        }

                    case ImageArrayElementTypes.Int16:
                        switch (rank)
                        {
                        case 2:         // Rank 2
                            short[,] short2dArray = new short[dimension1, dimension2];
                            Buffer.BlockCopy(imageBytes, dataStart, short2dArray, 0, imageBytes.Length - dataStart);
                            return(short2dArray);

                        case 3:         // Rank 3
                            short[,,] short3dArray = new short[dimension1, dimension2, dimension3];
                            Buffer.BlockCopy(imageBytes, dataStart, short3dArray, 0, imageBytes.Length - dataStart);
                            return(short3dArray);

                        default:
                            throw new InvalidValueException($"ToImageArray - Returned Int16 array cannot be handled because it does not have a rank of 2 or 3. Returned array rank:{rank}.");
                        }

                    case ImageArrayElementTypes.UInt16:
                        switch (rank)
                        {
                        case 2:         // Rank 2
                            UInt16[,] uInt16Array2D = new UInt16[dimension1, dimension2];
                            Buffer.BlockCopy(imageBytes, dataStart, uInt16Array2D, 0, imageBytes.Length - dataStart);
                            return(uInt16Array2D);

                        case 3:         // Rank 3
                            UInt16[,,] uInt16Array3D = new UInt16[dimension1, dimension2, dimension3];
                            Buffer.BlockCopy(imageBytes, dataStart, uInt16Array3D, 0, imageBytes.Length - dataStart);
                            return(uInt16Array3D);

                        default:
                            throw new InvalidValueException($"ToImageArray - Returned UInt16 array cannot be handled because it does not have a rank of 2 or 3. Returned array rank:{rank}.");
                        }

                    case ImageArrayElementTypes.Int32:
                        switch (rank)
                        {
                        case 2:         // Rank 2
                            int[,] int2dArray = new int[dimension1, dimension2];
                            Buffer.BlockCopy(imageBytes, dataStart, int2dArray, 0, imageBytes.Length - dataStart);
                            return(int2dArray);

                        case 3:         // Rank 3
                            int[,,] int3dArray = new int[dimension1, dimension2, dimension3];
                            Buffer.BlockCopy(imageBytes, dataStart, int3dArray, 0, imageBytes.Length - dataStart);
                            return(int3dArray);

                        default:
                            throw new InvalidValueException($"ToImageArray - Returned Int32 array cannot be handled because it does not have a rank of 2 or 3. Returned array rank:{rank}.");
                        }

                    case ImageArrayElementTypes.UInt32:
                        switch (rank)
                        {
                        case 2:         // Rank 2
                            UInt32[,] uInt32Array2D = new UInt32[dimension1, dimension2];
                            Buffer.BlockCopy(imageBytes, dataStart, uInt32Array2D, 0, imageBytes.Length - dataStart);
                            return(uInt32Array2D);

                        case 3:         // Rank 3
                            UInt32[,,] uInt32Array3D = new UInt32[dimension1, dimension2, dimension3];
                            Buffer.BlockCopy(imageBytes, dataStart, uInt32Array3D, 0, imageBytes.Length - dataStart);
                            return(uInt32Array3D);

                        default:
                            throw new InvalidValueException($"ToImageArray - Returned UInt32 array cannot be handled because it does not have a rank of 2 or 3. Returned array rank:{rank}.");
                        }

                    case ImageArrayElementTypes.Int64:
                        switch (rank)
                        {
                        case 2:         // Rank 2
                            Int64[,] int642dArray = new Int64[dimension1, dimension2];
                            Buffer.BlockCopy(imageBytes, dataStart, int642dArray, 0, imageBytes.Length - dataStart);
                            return(int642dArray);

                        case 3:         // Rank 3
                            Int64[,,] int643dArray = new Int64[dimension1, dimension2, dimension3];
                            Buffer.BlockCopy(imageBytes, dataStart, int643dArray, 0, imageBytes.Length - dataStart);
                            return(int643dArray);

                        default:
                            throw new InvalidValueException($"ToImageArray - Returned Int64 array cannot be handled because it does not have a rank of 2 or 3. Returned array rank:{rank}.");
                        }

                    case ImageArrayElementTypes.Single:
                        switch (rank)
                        {
                        case 2:         // Rank 2
                            Single[,] single2dArray = new Single[dimension1, dimension2];
                            Buffer.BlockCopy(imageBytes, dataStart, single2dArray, 0, imageBytes.Length - dataStart);
                            return(single2dArray);

                        case 3:         // Rank 3
                            Single[,,] single3dArray = new Single[dimension1, dimension2, dimension3];
                            Buffer.BlockCopy(imageBytes, dataStart, single3dArray, 0, imageBytes.Length - dataStart);
                            return(single3dArray);

                        default:
                            throw new InvalidValueException($"ToImageArray - Returned Int64 array cannot be handled because it does not have a rank of 2 or 3. Returned array rank:{rank}.");
                        }

                    case ImageArrayElementTypes.Double:
                        switch (rank)
                        {
                        case 2:         // Rank 2
                            Double[,] double2dArray = new Double[dimension1, dimension2];
                            Buffer.BlockCopy(imageBytes, dataStart, double2dArray, 0, imageBytes.Length - dataStart);
                            return(double2dArray);

                        case 3:         // Rank 3
                            Double[,,] double3dArray = new Double[dimension1, dimension2, dimension3];
                            Buffer.BlockCopy(imageBytes, dataStart, double3dArray, 0, imageBytes.Length - dataStart);
                            return(double3dArray);

                        default:
                            throw new InvalidValueException($"ToImageArray - Returned Int64 array cannot be handled because it does not have a rank of 2 or 3. Returned array rank:{rank}.");
                        }

                    case ImageArrayElementTypes.Decimal:
                        switch (rank)
                        {
                        case 2:         // Rank 2
                            Decimal[,] decimal2dArray = new Decimal[dimension1, dimension2];
                            Buffer.BlockCopy(imageBytes, dataStart, decimal2dArray, 0, imageBytes.Length - dataStart);
                            return(decimal2dArray);

                        case 3:         // Rank 3
                            Decimal[,,] decimal3dArray = new Decimal[dimension1, dimension2, dimension3];
                            Buffer.BlockCopy(imageBytes, dataStart, decimal3dArray, 0, imageBytes.Length - dataStart);
                            return(decimal3dArray);

                        default:
                            throw new InvalidValueException($"ToImageArray - Returned Int64 array cannot be handled because it does not have a rank of 2 or 3. Returned array rank:{rank}.");
                        }

                    default:
                        throw new InvalidValueException($"ToImageArray - The device has returned an unsupported image array element type: {imageElementType}.");
                    }
                }
                else // An unsupported combination of array element types has been returned
                {
                    throw new InvalidValueException($"ToImageArray - The device has returned an unsupported combination of Output type: {imageElementType} and Transmission type: {transmissionElementType}.");
                }
            }
        }