Ejemplo n.º 1
0
        private static void read_color_images(KeyenceFile kfile, BinaryReader p)
        {
            KeyenceOffsetTable offtable = kfile.offset_table;

            kfile.color_peak = new KeyenceTrueColorImage();
            read_color_image(kfile, kfile.color_peak, offtable.color_peak, p);
            kfile.color_light = new KeyenceTrueColorImage();
            read_color_image(kfile, kfile.color_light, offtable.color_light, p);
        }
Ejemplo n.º 2
0
        private static void read_data_image(KeyenceFile kfile, KeyenceFalseColorImage image, uint offset, BinaryReader p)
        {
            uint size = (uint)p.BaseStream.Length;
            uint bps;

            if (offset == 0)
            {
                return;
            }

            if (size <= KEYENCE_FALSE_COLOR_IMAGE_MIN_SIZE || offset > size - KEYENCE_FALSE_COLOR_IMAGE_MIN_SIZE)
            {
                throw new Exception("Stream size not enouth to read");
            }

            p.BaseStream.Position = offset;

            image.width = p.ReadUInt32();
            if (err_DIMENSION(image.width))
            {
                throw new Exception("Dimension Error");
            }
            image.height = p.ReadUInt32();
            if (err_DIMENSION(image.height))
            {
                throw new Exception("Dimension Error");
            }

            image.bit_depth = p.ReadUInt32();
            if (image.bit_depth != 8 && image.bit_depth != 16 && image.bit_depth != 32)
            {
                throw new Exception("BPP Error");
            }

            bps = image.bit_depth / 8;

            image.compression = p.ReadUInt32();
            image.byte_size   = p.ReadUInt32();
            if (err_SIZE_MISMATCH(image.width * image.height * bps, image.byte_size, true))
            {
                throw new Exception("Size Mismatch Error");
            }

            image.palette_range_min = p.ReadUInt32();
            image.palette_range_max = p.ReadUInt32();

            p.BaseStream.Read(image.palette, 0, image.palette.Length);

            if (size - offset - KEYENCE_FALSE_COLOR_IMAGE_MIN_SIZE < image.byte_size)
            {
                throw new Exception("Stream size not enouth to read");
            }
            image.data = p.ReadBytes((int)image.byte_size);
            kfile.nimages++;
        }
Ejemplo n.º 3
0
        private static void read_data_images(KeyenceFile kfile, BinaryReader p)
        {
            KeyenceOffsetTable offtable = kfile.offset_table;
            uint i;

            for (i = 0; i < kfile.light.Length; i++)
            {
                kfile.light[i] = new KeyenceFalseColorImage();
                read_data_image(kfile, kfile.light[i], offtable.light[i], p);
            }
            for (i = 0; i < kfile.height.Length; i++)
            {
                kfile.height[i] = new KeyenceFalseColorImage();
                read_data_image(kfile, kfile.height[i], offtable.height[i], p);
            }
        }
Ejemplo n.º 4
0
        private static void read_line_meas(KeyenceFile kfile, BinaryReader p)
        {
            uint size = (uint)p.BaseStream.Length;
            uint off  = kfile.offset_table.line_measure;
            uint i;

            if (off == 0)
            {
                return;
            }

            if (size <= KEYENCE_LINE_MEASUREMENT_SIZE || off > size - KEYENCE_LINE_MEASUREMENT_SIZE)
            {
                throw new Exception("Stream size not enouth to read");
            }

            p.BaseStream.Position = off;

            kfile.line_measure = new KeyenceLineMeasurement();
            KeyenceLineMeasurement linemeas = kfile.line_measure;

            linemeas.size = p.ReadUInt32();
            if (size < KEYENCE_LINE_MEASUREMENT_SIZE)
            {
                throw new Exception("Stream size not enouth to read");
            }
            linemeas.line_width = p.ReadUInt32();

            /* XXX: We should use the real length even though the format description
             * seems to specify a fixed length.  Also note that only the first data
             * block is supposed to be used; the rest it reserved. */
            for (i = 0; i < linemeas.light.Length; i++)
            {
                linemeas.light[i] = p.ReadBytes(KEYENCE_LINE_MEASUREMENT_LEN * sizeof(UInt16));
            }
            for (i = 0; i < linemeas.height.Length; i++)
            {
                linemeas.height[i] = p.ReadBytes(KEYENCE_LINE_MEASUREMENT_LEN * sizeof(UInt32));
            }
        }
Ejemplo n.º 5
0
        private static void read_character_strs(KeyenceFile kfile, BinaryReader p)
        {
            KeyenceCharacterStrings charstrs;
            uint remsize = (uint)p.BaseStream.Length;
            uint off     = kfile.offset_table.string_data;

            if (off == 0)
            {
                return;
            }

            if (remsize < off)
            {
                throw new Exception("Stream size not enouth to read");
            }

            p.BaseStream.Position = off;
            remsize           -= off;
            charstrs           = kfile.char_strs = new KeyenceCharacterStrings();
            charstrs.title     = read_character_str(p, ref remsize);
            charstrs.lens_name = read_character_str(p, ref remsize);
        }
Ejemplo n.º 6
0
        public static KeyenceFile LoadVk4FromStream(Stream stream)
        {
            using (BinaryReader p = new BinaryReader(stream)) {
                KeyenceFile kfile = new KeyenceFile();

                kfile.header       = read_header(p);
                kfile.offset_table = read_offset_table(p);
                kfile.meas_conds   = read_meas_conds(p);
                read_assembly_info(kfile, p);
                read_data_images(kfile, p);
                read_color_images(kfile, p);
                read_line_meas(kfile, p);
                read_character_strs(kfile, p);

                if (kfile.nimages == 0)
                {
                    throw new Exception("ni image data");
                }

                return(kfile);
            }
        }
Ejemplo n.º 7
0
        private static void read_assembly_info(KeyenceFile kfile, BinaryReader p)
        {
            uint size = (uint)p.BaseStream.Length;
            uint off = kfile.offset_table.assemble;
            uint remsize, nfiles, i, j;

            if (off == 0)
            {
                return;
            }

            if (size <= KEYENCE_ASSEMBLY_HEADERS_SIZE || off > size - KEYENCE_ASSEMBLY_HEADERS_SIZE)
            {
                throw new Exception("Stream size not enouth to read");
            }

            p.BaseStream.Position = off;

            kfile.assembly_info            = new KeyenceAssemblyInformation();
            kfile.assembly_info.size       = p.ReadUInt32();
            kfile.assembly_info.file_type  = (KeyenceFileType)p.ReadUInt16();
            kfile.assembly_info.stage_type = p.ReadUInt16();
            kfile.assembly_info.x_position = p.ReadUInt32();
            kfile.assembly_info.y_position = p.ReadUInt32();

            kfile.assembly_conds = new KeyenceAssemblyConditions();
            kfile.assembly_conds.auto_adjustment = p.ReadByte();
            kfile.assembly_conds.source          = p.ReadByte();
            kfile.assembly_conds.thin_out        = p.ReadUInt16();
            kfile.assembly_conds.count_x         = p.ReadUInt16();
            kfile.assembly_conds.count_y         = p.ReadUInt16();

            nfiles = kfile.assembly_conds.count_x * kfile.assembly_conds.count_y;
            if (nfiles == 0)
            {
                return;
            }

            remsize = size - KEYENCE_ASSEMBLY_HEADERS_SIZE - off;

            if (remsize / nfiles < KEYENCE_ASSEMBLY_FILE_SIZE)
            {
                /* Apparently there can be large counts but no actual assembly data.
                 * I do not understand but we to not use the infomation for anything
                 * anyway. */
                kfile.assembly_conds.count_x = 0;
                kfile.assembly_conds.count_y = 0;
                kfile.assembly_nfiles        = 0;
                return;
            }

            kfile.assembly_nfiles = nfiles;
            kfile.assembly_files  = new KeyenceAssemblyFile[nfiles];
            for (i = 0; i < nfiles; i++)
            {
                kfile.assembly_files[i] = new KeyenceAssemblyFile();
                KeyenceAssemblyFile kafile = kfile.assembly_files[i];

                for (j = 0; j < kafile.source_file.Length; j++)
                {
                    kafile.source_file[j] = p.ReadUInt16();
                }
                kafile.pos_x        = p.ReadByte();
                kafile.pos_y        = p.ReadByte();
                kafile.datums_pos   = p.ReadByte();
                kafile.fix_distance = p.ReadByte();
                kafile.distance_x   = p.ReadUInt32();
                kafile.distance_y   = p.ReadUInt32();
            }
        }