Beispiel #1
0
        public override void ParseData()
        {
            BaseUnit    = (Converters.eMeasurement)Data[0];
            HResolution = GetNumericValueFromData <ushort>(1, 2);
            VResolution = GetNumericValueFromData <ushort>(3, 2);
            XSize       = GetNumericValueFromData <ushort>(5, 2);
            YSize       = GetNumericValueFromData <ushort>(7, 2);

            // Since there is one IDD per image object container, it is efficient enough to load them at this point
            SDFs = ImageSelfDefiningField.GetAllSDFs(Data.Skip(9).ToArray());
        }
Beispiel #2
0
        private void ParseFontAndImageData()
        {
            // FONT RASTER PATTERNS
            Dictionary <Container, IReadOnlyDictionary <FNI.Info, bool[, ]> > rasterPatterns = new Dictionary <Container, IReadOnlyDictionary <FNI.Info, bool[, ]> >();

            foreach (Container c in Resources.Where(r => r.ResourceType == Resource.eResourceType.FontCharacterSet && r.IsLoaded)
                     .Select(r => r.Fields[0].LowestLevelContainer))
            {
                // If we have a pattern map, gather raster data
                FNM patternsMap = c.GetStructure <FNM>();
                if (patternsMap != null)
                {
                    FNI firstFNI = c.GetStructure <FNI>();
                    Dictionary <FNI.Info, bool[, ]> patternsDictionary = new Dictionary <FNI.Info, bool[, ]>();
                    byte[] allFNGData   = c.GetStructures <FNG>().SelectMany(f => f.Data).ToArray();
                    int    indexCounter = 0;

                    for (int i = 0; i < patternsMap.AllPatternData.Count; i++)
                    {
                        // Subtract the next offset (or length of data if at end) by this one to find out how many bytes to take
                        int bytesToTake = (int)((i < patternsMap.AllPatternData.Count - 1 ? patternsMap.AllPatternData[i + 1].DataOffset : (uint)allFNGData.Length)
                                                - patternsMap.AllPatternData[i].DataOffset);

                        // Create an empty array of bools from our box width and height
                        // The array sizes are the number of bits in the minimum number of bytes required to support the bit size
                        int numBitsWide = (int)Math.Ceiling((patternsMap.AllPatternData[i].BoxMaxWidthIndex + 1) / 8.0) * 8;
                        int numRows     = bytesToTake / (numBitsWide / 8);
                        bool[,] curPattern = new bool[numBitsWide, numRows];
                        for (int y = 0; y < numRows; y++)
                        {
                            for (int x = 0; x < numBitsWide; x += 8)
                            {
                                byte curByte = allFNGData[indexCounter++];
                                for (int b = 0; b < 8; b++)
                                {
                                    curPattern[x + b, y] = (curByte & (1 << (7 - b))) > 0;
                                }
                            }
                        }

                        // Lookup the GCGID from the first FNI for this pattern
                        patternsDictionary.Add(firstFNI.InfoList.First(fni => fni.FNMIndex == i), curPattern);
                    }
                    rasterPatterns.Add(c, patternsDictionary);
                }
            }
            ParsedFontPatterns = rasterPatterns;

            // IM IMAGES
            Dictionary <Container, IReadOnlyList <IMImageCell> > imImages = new Dictionary <Container, IReadOnlyList <IMImageCell> >();

            foreach (Container c in Resources
                     .Where(r => r.IsLoaded && (r.ResourceType == Resource.eResourceType.IMImage || (r.ResourceType == Resource.eResourceType.PageSegment && r.Fields[1] is BII)))
                     .Select(r => r.ResourceType == Resource.eResourceType.PageSegment ? r.Fields[1].LowestLevelContainer : r.Fields[0].LowestLevelContainer))
            {
                IID imageDescriptor         = c.GetStructure <IID>();
                List <IMImageCell> cellList = new List <IMImageCell>();

                if (c.GetStructure <ICP>() == null)
                {
                    // Since there are no cells, create one
                    ICP         newCellPos = new ICP(imageDescriptor.XSize, imageDescriptor.YSize);
                    IMImageCell newCell    = new IMImageCell(newCellPos, c.GetStructures <IRD>());
                    cellList.Add(newCell);
                }
                else
                {
                    // Manually parse a list of cells since they don't have their own container
                    for (int i = 0; i < c.Structures.Count; i++)
                    {
                        if (c.Structures[i].GetType() != typeof(ICP))
                        {
                            continue;
                        }

                        // Get list of IRDs up to the next ICP or end of structures
                        List <IRD> rasterData = new List <IRD>();
                        for (int r = i + 1; r < c.Structures.Count; r++)
                        {
                            if (c.Structures[r].GetType() != typeof(IRD))
                            {
                                break;
                            }
                            rasterData.Add((IRD)c.Structures[r]);
                        }

                        cellList.Add(new IMImageCell((ICP)c.Structures[i], rasterData));
                    }
                }
                imImages.Add(c, cellList);
            }
            ParsedIMImages = imImages;

            // IOCA IMAGES
            Dictionary <Container, IReadOnlyList <ImageInfo> > iocaImages = new Dictionary <Container, IReadOnlyList <ImageInfo> >();

            foreach (Container c in Resources
                     .Where(r => r.IsLoaded && (r.ResourceType == Resource.eResourceType.IOCAImage || (r.ResourceType == Resource.eResourceType.PageSegment && r.Fields[1] is BIM)))
                     .Select(r => r.ResourceType == Resource.eResourceType.PageSegment ? r.Fields[1].LowestLevelContainer : r.Fields[0].LowestLevelContainer))
            {
                // Combine all self defining fields from zero or more IPD fields
                byte[] allIPDData = c.GetStructures <IPD>().SelectMany(f => f.Data).ToArray();
                List <ImageSelfDefiningField> SDFs = ImageSelfDefiningField.GetAllSDFs(allIPDData);

                // Get all images in our self defining field list
                foreach (Container sc in SDFs.OfType <BeginImageContent>().Select(s => s.LowestLevelContainer))
                {
                    List <Container> allContainers = new List <Container>()
                    {
                        sc
                    };
                    List <ImageInfo> infoList = new List <ImageInfo>();

                    // Along with ourself, add any tiles to the list of containers
                    if (sc.Structures.Any(s => s.GetType() == typeof(BeginTile)))
                    {
                        allContainers.AddRange(sc.Structures.OfType <BeginTile>().Select(s => s.LowestLevelContainer));
                    }

                    // For each container, get image and transparency bytes
                    foreach (Container tc in allContainers)
                    {
                        ImageInfo info = new ImageInfo();
                        info.Data = tc.DirectGetStructures <ImageData>().SelectMany(s => s.Data).ToArray();

                        // If there are tiles, store offset information
                        if (tc.Structures[0].GetType() == typeof(BeginTile))
                        {
                            TilePosition tp = tc.GetStructure <TilePosition>();
                            info.XOffset = tp.XOffset;
                            info.YOffset = tp.YOffset;
                        }

                        // Add transparency data if needed
                        ImageSelfDefiningField BTM = tc.GetStructure <BeginTransparencyMask>();
                        if (BTM != null)
                        {
                            info.TransparencyMask = BTM.LowestLevelContainer.GetStructures <ImageData>().SelectMany(s => s.Data).ToArray();
                        }

                        infoList.Add(info);
                    }
                    iocaImages.Add(c, infoList);
                }
            }
            ParsedImages = iocaImages;
        }