geomerative 0.1.0-java

data/src/org/apache/batik/svggen/font/table/GlyfCompositeDescript.java

@@ -0,0 +1,160 @@
+/*
+
+   Copyright 2001,2003  The Apache Software Foundation 
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+package org.apache.batik.svggen.font.table;
+
+import java.io.ByteArrayInputStream;
+import java.util.ArrayList;
+
+/**
+ * Glyph description for composite glyphs.  Composite glyphs are made up of one
+ * or more simple glyphs, usually with some sort of transformation applied to
+ * each.
+ *
+ * @version $Id: GlyfCompositeDescript.java,v 1.5 2004/08/18 07:15:20 vhardy Exp $
+ * @author <a href="mailto:david@steadystate.co.uk">David Schweinsberg</a>
+ */
+public class GlyfCompositeDescript extends GlyfDescript {
+
+    private final ArrayList<GlyfCompositeComp> components;
+
+    public GlyfCompositeDescript(GlyfTable parentTable, 
+                                 ByteArrayInputStream bais) {
+        super(parentTable, (short) -1, bais);
+        this.components = new ArrayList<>();
+        
+        // Get all of the composite components
+        GlyfCompositeComp comp;
+        int firstIndex = 0;
+        int firstContour = 0;
+        do {
+            comp = new GlyfCompositeComp(firstIndex, firstContour, bais);
+            components.add(comp);
+
+            GlyphDescription desc;
+            desc = parentTable.getDescription(comp.getGlyphIndex());
+            if (desc != null) {
+                firstIndex   += desc.getPointCount();
+                firstContour += desc.getContourCount();
+            }
+        } while ((comp.getFlags() & GlyfCompositeComp.MORE_COMPONENTS) != 0);
+
+        // Are there hinting intructions to read?
+        if ((comp.getFlags() & GlyfCompositeComp.WE_HAVE_INSTRUCTIONS) != 0) {
+            readInstructions(bais, (bais.read()<<8 | bais.read()));
+        }
+    }
+
+    @Override
+    public int getEndPtOfContours(int i) {
+        GlyfCompositeComp c = getCompositeCompEndPt(i);
+        if (c != null) {
+            GlyphDescription gd = parentTable.getDescription(c.getGlyphIndex());
+            return gd.getEndPtOfContours(i - c.getFirstContour()) + c.getFirstIndex();
+        }
+        return 0;
+    }
+
+    @Override
+    public byte getFlags(int i) {
+        GlyfCompositeComp c = getCompositeComp(i);
+        if (c != null) {
+            GlyphDescription gd = parentTable.getDescription(c.getGlyphIndex());
+            return gd.getFlags(i - c.getFirstIndex());
+        }
+        return 0;
+    }
+
+    @Override
+    public short getXCoordinate(int i) {
+        GlyfCompositeComp c = getCompositeComp(i);
+        if (c != null) {
+            GlyphDescription gd = parentTable.getDescription(c.getGlyphIndex());
+            int n = i - c.getFirstIndex();
+            int x = gd.getXCoordinate(n);
+            int y = gd.getYCoordinate(n);
+            short x1 = (short) c.scaleX(x, y);
+            x1 += c.getXTranslate();
+            return x1;
+        }
+        return 0;
+    }
+
+    @Override
+    public short getYCoordinate(int i) {
+        GlyfCompositeComp c = getCompositeComp(i);
+        if (c != null) {
+            GlyphDescription gd = parentTable.getDescription(c.getGlyphIndex());
+            int n = i - c.getFirstIndex();
+            int x = gd.getXCoordinate(n);
+            int y = gd.getYCoordinate(n);
+            short y1 = (short) c.scaleY(x, y);
+            y1 += c.getYTranslate();
+            return y1;
+        }
+        return 0;
+    }
+
+    @Override
+    public boolean isComposite() {
+        return true;
+    }
+
+    @Override
+    public int getPointCount() {
+        GlyfCompositeComp c = (GlyfCompositeComp) components.get(components.size()-1);
+        return c.getFirstIndex() + parentTable.getDescription(c.getGlyphIndex()).getPointCount();
+    }
+
+    @Override
+    public int getContourCount() {
+        GlyfCompositeComp c = (GlyfCompositeComp) components.get(components.size()-1);
+        return c.getFirstContour() + parentTable.getDescription(c.getGlyphIndex()).getContourCount();
+    }
+
+    public int getComponentIndex(int i) {
+        return ((GlyfCompositeComp)components.get(i)).getFirstIndex();
+    }
+
+    public int getComponentCount() {
+        return components.size();
+    }
+
+    protected GlyfCompositeComp getCompositeComp(int i) {
+        GlyfCompositeComp c;
+        for (Object component : components) {
+            c = (GlyfCompositeComp) component;
+            GlyphDescription gd = parentTable.getDescription(c.getGlyphIndex());
+            if (c.getFirstIndex() <= i && i < (c.getFirstIndex() + gd.getPointCount())) {
+                return c;
+            }
+        }
+        return null;
+    }
+
+    protected GlyfCompositeComp getCompositeCompEndPt(int i) {
+        GlyfCompositeComp c;
+        for (Object component : components) {
+            c = (GlyfCompositeComp) component;
+            GlyphDescription gd = parentTable.getDescription(c.getGlyphIndex());
+            if (c.getFirstContour() <= i && i < (c.getFirstContour() + gd.getContourCount())) {
+                return c;
+            }
+        }
+        return null;
+    }
+}

data/src/org/apache/batik/svggen/font/table/GlyfDescript.java

@@ -0,0 +1,79 @@
+/*
+
+   Copyright 2001  The Apache Software Foundation 
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+package org.apache.batik.svggen.font.table;
+
+import java.io.ByteArrayInputStream;
+
+/**
+ * @version $Id: GlyfDescript.java,v 1.3 2004/08/18 07:15:21 vhardy Exp $
+ * @author <a href="mailto:david@steadystate.co.uk">David Schweinsberg</a>
+ */
+public abstract class GlyfDescript extends Program implements GlyphDescription {
+
+    // flags
+    public static final byte onCurve = 0x01;
+    public static final byte xShortVector = 0x02;
+    public static final byte yShortVector = 0x04;
+    public static final byte repeat = 0x08;
+    public static final byte xDual = 0x10;
+    public static final byte yDual = 0x20;
+
+    protected GlyfTable parentTable;
+    private final int numberOfContours;
+    private final short xMin;
+    private final short yMin;
+    private final short xMax;
+    private final short yMax;
+
+    protected GlyfDescript(GlyfTable parentTable, short numberOfContours, ByteArrayInputStream bais) {
+        this.parentTable = parentTable;
+        this.numberOfContours = numberOfContours;
+        xMin = (short)(bais.read()<<8 | bais.read());
+        yMin = (short)(bais.read()<<8 | bais.read());
+        xMax = (short)(bais.read()<<8 | bais.read());
+        yMax = (short)(bais.read()<<8 | bais.read());
+    }
+
+    public int getNumberOfContours() {
+        return numberOfContours;
+    }
+
+    @Override
+    public short getXMaximum() {
+        return xMax;
+    }
+
+    @Override
+    public short getXMinimum() {
+        return xMin;
+    }
+
+    @Override
+    public short getYMaximum() {
+        return yMax;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public short getYMinimum() {
+        return yMin;
+    }
+}

data/src/org/apache/batik/svggen/font/table/GlyfSimpleDescript.java

@@ -0,0 +1,155 @@
+/*
+
+   Copyright 2001,2003  The Apache Software Foundation 
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+package org.apache.batik.svggen.font.table;
+
+import java.io.ByteArrayInputStream;
+
+/**
+ * @version $Id: GlyfSimpleDescript.java,v 1.4 2004/08/18 07:15:21 vhardy Exp $
+ * @author <a href="mailto:david@steadystate.co.uk">David Schweinsberg</a>
+ */
+public class GlyfSimpleDescript extends GlyfDescript {
+
+    private final int[] endPtsOfContours;
+    private final byte[] flags;
+    private final short[] xCoordinates;
+    private final short[] yCoordinates;
+    private final int count;
+
+    public GlyfSimpleDescript(GlyfTable parentTable, short numberOfContours, ByteArrayInputStream bais) {
+
+        super(parentTable, numberOfContours, bais);
+        
+        // Simple glyph description
+        endPtsOfContours = new int[numberOfContours];
+        for (int i = 0; i < numberOfContours; i++) {
+            endPtsOfContours[i] = (bais.read()<<8 | bais.read());
+        }
+
+        // The last end point index reveals the total number of points
+        count = endPtsOfContours[numberOfContours-1] + 1;
+        flags = new byte[count];
+        xCoordinates = new short[count];
+        yCoordinates = new short[count];
+
+        int instructionCount = (bais.read()<<8 | bais.read());
+        readInstructions(bais, instructionCount);
+        readFlags(count, bais);
+        readCoords(count, bais);
+    }
+
+    @Override
+    public int getEndPtOfContours(int i) {
+        return endPtsOfContours[i];
+    }
+
+    @Override
+    public byte getFlags(int i) {
+        return flags[i];
+    }
+
+    @Override
+    public short getXCoordinate(int i) {
+        return xCoordinates[i];
+    }
+
+    @Override
+    public short getYCoordinate(int i) {
+        return yCoordinates[i];
+    }
+
+    @Override
+    public boolean isComposite() {
+        return false;
+    }
+
+    @Override
+    public int getPointCount() {
+        return count;
+    }
+
+    @Override
+    public int getContourCount() {
+        return getNumberOfContours();
+    }
+    /*
+    public int getComponentIndex(int c) {
+    return 0;
+    }
+
+    public int getComponentCount() {
+    return 1;
+    }
+     */
+    /**
+     * The table is stored as relative values, but we'll store them as absolutes
+     */
+    private void readCoords(int count, ByteArrayInputStream bais) {
+        short x = 0;
+        short y = 0;
+        for (int i = 0; i < count; i++) {
+            if ((flags[i] & xDual) != 0) {
+                if ((flags[i] & xShortVector) != 0) {
+                    x += (short) bais.read();
+                }
+            } else {
+                if ((flags[i] & xShortVector) != 0) {
+                    x += (short) -((short) bais.read());
+                } else {
+                    x += (short)(bais.read()<<8 | bais.read());
+                }
+            }
+            xCoordinates[i] = x;
+        }
+
+        for (int i = 0; i < count; i++) {
+            if ((flags[i] & yDual) != 0) {
+                if ((flags[i] & yShortVector) != 0) {
+                    y += (short) bais.read();
+                }
+            } else {
+                if ((flags[i] & yShortVector) != 0) {
+                    y += (short) -((short) bais.read());
+                } else {
+                    y += (short)(bais.read()<<8 | bais.read());
+                }
+            }
+            yCoordinates[i] = y;
+        }
+    }
+
+    /**
+     * The flags are run-length encoded
+     */
+    private void readFlags(int flagCount, ByteArrayInputStream bais) {
+        try {
+            for (int index = 0; index < flagCount; index++) {
+                flags[index] = (byte) bais.read();
+                if ((flags[index] & repeat) != 0) {
+                    int repeats = bais.read();
+                    for (int i = 1; i <= repeats; i++) {
+                        flags[index + i] = flags[index];
+                    }
+                    index += repeats;
+                }
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("error: array index out of bounds");
+        }
+    }
+}

data/src/org/apache/batik/svggen/font/table/GlyfTable.java

@@ -0,0 +1,111 @@
+/*
+
+   Copyright 2001,2003  The Apache Software Foundation 
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ */
+package org.apache.batik.svggen.font.table;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import org.apache.batik.svggen.font.*;
+
+/**
+ * @version $Id: GlyfTable.java,v 1.4 2004/08/18 07:15:21 vhardy Exp $
+ * @author <a href="mailto:david@steadystate.co.uk">David Schweinsberg</a>
+ */
+public class GlyfTable implements Table {
+
+    private byte[] buf = null;
+    private GlyfDescript[] descript;
+
+    protected GlyfTable(DirectoryEntry de, RandomAccessFileEmulator raf) throws IOException {
+        raf.seek(de.getOffset());
+        buf = new byte[de.getLength()];
+        raf.read(buf);
+/*
+        TableMaxp t_maxp = (TableMaxp) td.getEntryByTag(maxp).getTable();
+        TableLoca t_loca = (TableLoca) td.getEntryByTag(loca).getTable();
+        descript = new TableGlyfDescript[t_maxp.getNumGlyphs()];
+        for (int i = 0; i < t_maxp.getNumGlyphs(); i++) {
+            raf.seek(tde.getOffset() + t_loca.getOffset(i));
+            int len = t_loca.getOffset((short)(i + 1)) - t_loca.getOffset(i);
+            if (len > 0) {
+                short numberOfContours = raf.readShort();
+                if (numberOfContours < 0) {
+                    //          descript[i] = new TableGlyfCompositeDescript(this, raf);
+                } else {
+                    descript[i] = new TableGlyfSimpleDescript(this, numberOfContours, raf);
+                }
+            } else {
+                descript[i] = null;
+            }
+        }
+
+        for (int i = 0; i < t_maxp.getNumGlyphs(); i++) {
+            raf.seek(tde.getOffset() + t_loca.getOffset(i));
+            int len = t_loca.getOffset((short)(i + 1)) - t_loca.getOffset(i);
+            if (len > 0) {
+                short numberOfContours = raf.readShort();
+                if (numberOfContours < 0) {
+                    descript[i] = new TableGlyfCompositeDescript(this, raf);
+                }
+            }
+        }
+*/
+    }
+
+    public void init(int numGlyphs, LocaTable loca) {
+        if (buf == null) {
+            return;
+        }
+        descript = new GlyfDescript[numGlyphs];
+        ByteArrayInputStream bais = new ByteArrayInputStream(buf);
+        for (int i = 0; i < numGlyphs; i++) {
+            int len = loca.getOffset((short)(i + 1)) - loca.getOffset(i);
+            if (len > 0) {
+                bais.reset();
+                bais.skip(loca.getOffset(i));
+                short numberOfContours = (short)(bais.read()<<8 | bais.read());
+                if (numberOfContours >= 0) {
+                    descript[i] = new GlyfSimpleDescript(this, numberOfContours, bais);
+                }
+            } else {
+                descript[i] = null;
+            }
+        }
+
+        for (int i = 0; i < numGlyphs; i++) {
+            int len = loca.getOffset((short)(i + 1)) - loca.getOffset(i);
+            if (len > 0) {
+                bais.reset();
+                bais.skip(loca.getOffset(i));
+                short numberOfContours = (short)(bais.read()<<8 | bais.read());
+                if (numberOfContours < 0) {
+                    descript[i] = new GlyfCompositeDescript(this, bais);
+                }
+            }
+        }
+        buf = null;
+    }
+
+    public GlyfDescript getDescription(int i) {
+        return descript[i];
+    }
+
+    @Override
+    public int getType() {
+        return glyf;
+    }
+}