public void end_poly(ShapePath.FlagsAndCommand flags) { if (ShapePath.is_vertex(vertices.last_command())) { vertices.AddVertex(0.0, 0.0, ShapePath.FlagsAndCommand.CommandEndPoly | flags); } }
public static void Save(IVertexSource vertexSource, string pathAndFileName, bool oldStyle = true) { if (oldStyle) { using (StreamWriter outFile = new StreamWriter(pathAndFileName)) { vertexSource.rewind(0); double x; double y; ShapePath.FlagsAndCommand flagsAndCommand = vertexSource.vertex(out x, out y); do { outFile.WriteLine("{0}, {1}, {2}", x, y, flagsAndCommand.ToString()); flagsAndCommand = vertexSource.vertex(out x, out y); }while (flagsAndCommand != ShapePath.FlagsAndCommand.Stop); } } else { using (StreamWriter outFile = new StreamWriter(pathAndFileName)) { foreach (VertexData vertexData in vertexSource.Vertices()) { outFile.WriteLine("{0}, {1}, {2}", vertexData.position.X, vertexData.position.Y, vertexData.command.ToString()); } } } }
public override ShapePath.FlagsAndCommand vertex(out double x, out double y) { x = 0; y = 0; ShapePath.FlagsAndCommand cmd = ShapePath.FlagsAndCommand.CommandStop; switch (m_idx) { case 0: case 1: case 2: cmd = m_stroke.vertex(out x, out y); break; case 3: case 4: case 5: case 6: cmd = m_ellipse.vertex(out x, out y); break; } if (!ShapePath.is_stop(cmd)) { ParentToChildTransform.transform(ref x, ref y); } return(cmd); }
public void AddVertex(double x, double y, ShapePath.FlagsAndCommand cmd) { m_status = StrokeMath.status_e.initial; if (ShapePath.is_move_to(cmd)) { m_src_vertices.modify_last(new VertexDistance(x, y)); } else { if (ShapePath.is_vertex(cmd)) { m_src_vertices.add(new VertexDistance(x, y)); } else { if (ShapePath.is_end_poly(cmd)) { m_closed = (ShapePath.get_close_flag(cmd) == ShapePath.FlagsAndCommand.FlagClose); if (m_orientation == ShapePath.FlagsAndCommand.FlagNone) { m_orientation = ShapePath.get_orientation(cmd); } } } } }
static public bool OldEqualsNewStyle(IVertexSource control, IVertexSource test, double maxError = .0001) { control.rewind(0); double controlX; double controlY; ShapePath.FlagsAndCommand controlFlagsAndCommand = control.vertex(out controlX, out controlY); int index = 0; foreach (VertexData vertexData in test.Vertices()) { if (controlFlagsAndCommand != vertexData.command || controlX < vertexData.position.x - maxError || controlX > vertexData.position.x + maxError || controlY < vertexData.position.y - maxError || controlY > vertexData.position.y + maxError) { return(false); } controlFlagsAndCommand = control.vertex(out controlX, out controlY); index++; } if (controlFlagsAndCommand == ShapePath.FlagsAndCommand.CommandStop) { return(true); } return(false); }
private void allocate_if_required(int indexToAdd) { if (indexToAdd < m_num_vertices) { return; } while (indexToAdd >= m_allocated_vertices) { int newSize = m_allocated_vertices + 256; double[] newX = new double[newSize]; double[] newY = new double[newSize]; ShapePath.FlagsAndCommand[] newCmd = new ShapePath.FlagsAndCommand[newSize]; if (m_coord_x != null) { for (int i = 0; i < m_num_vertices; i++) { newX[i] = m_coord_x[i]; newY[i] = m_coord_y[i]; newCmd[i] = m_CommandAndFlags[i]; } } m_coord_x = newX; m_coord_y = newY; m_CommandAndFlags = newCmd; m_allocated_vertices = newSize; } }
public void end_poly(ShapePath.FlagsAndCommand flags) { if (ShapePath.is_vertex(vertexDataManager.last_command())) { vertexDataManager.AddVertex(0.0, 0.0, ShapePath.FlagsAndCommand.EndPoly | flags); } }
public void AddVertex(double x, double y, ShapePath.FlagsAndCommand CommandAndFlags, int index = -1) { index = index == -1 ? numVertices : index; allocate_if_required(numVertices); vertexData[index] = new VertexData(CommandAndFlags, x, y); numVertices++; }
public ShapePath.FlagsAndCommand vertex(out double x, out double y) { ShapePath.FlagsAndCommand cmd = VertexSource.vertex(out x, out y); if (ShapePath.is_vertex(cmd)) { ApplayYWarp(ref x, ref y); } return(cmd); }
public ShapePath.FlagsAndCommand vertex(out double x, out double y) { ShapePath.FlagsAndCommand cmd = VertexSource.vertex(out x, out y); if (ShapePath.is_vertex(cmd)) { transformToApply.transform(ref x, ref y); } return(cmd); }
public void AddVertex(double x, double y, ShapePath.FlagsAndCommand CommandAndFlags) { allocate_if_required(m_num_vertices); m_coord_x[m_num_vertices] = x; m_coord_y[m_num_vertices] = y; m_CommandAndFlags[m_num_vertices] = CommandAndFlags; m_num_vertices++; }
public override ShapePath.FlagsAndCommand vertex(out double x, out double y) { x = 0; y = 0; ShapePath.FlagsAndCommand cmd = ShapePath.FlagsAndCommand.LineTo; switch (m_idx) { case 0: if (m_vertex == 0) { cmd = ShapePath.FlagsAndCommand.MoveTo; } if (m_vertex >= 4) { cmd = ShapePath.FlagsAndCommand.Stop; } x = m_vx[m_vertex]; y = m_vy[m_vertex]; m_vertex++; break; case 1: if (m_vertex == 0 || m_vertex == 4) { cmd = ShapePath.FlagsAndCommand.MoveTo; } if (m_vertex >= 8) { cmd = ShapePath.FlagsAndCommand.Stop; } x = m_vx[m_vertex]; y = m_vy[m_vertex]; m_vertex++; break; case 2: cmd = m_curve_poly.vertex(out x, out y); break; case 3: case 4: cmd = m_curve_pnt.vertex(out x, out y); break; default: cmd = ShapePath.FlagsAndCommand.Stop; break; } if (!ShapePath.is_stop(cmd)) { //OriginRelativeParentTransform.transform(ref x, ref y); } return(cmd); }
public ShapePath.FlagsAndCommand vertex(out double x, out double y) { x = currentEnumerator.Current.position.x; y = currentEnumerator.Current.position.y; ShapePath.FlagsAndCommand command = currentEnumerator.Current.command; currentEnumerator.MoveNext(); return(command); }
public void swap_vertices(int v1, int v2) { double val; val = m_coord_x[v1]; m_coord_x[v1] = m_coord_x[v2]; m_coord_x[v2] = val; val = m_coord_y[v1]; m_coord_y[v1] = m_coord_y[v2]; m_coord_y[v2] = val; ShapePath.FlagsAndCommand cmd = m_CommandAndFlags[v1]; m_CommandAndFlags[v1] = m_CommandAndFlags[v2]; m_CommandAndFlags[v2] = cmd; }
public void flip_y(double y1, double y2) { for (int i = 0; i < vertexDataManager.total_vertices(); i++) { ShapePath.FlagsAndCommand PathAndFlags = vertexDataManager.vertex(i, out double x, out double y); if (ShapePath.is_vertex(PathAndFlags)) { vertexDataManager.modify_vertex(i, x, y2 - y + y1); } } }
public void arrange_orientations_all_paths(ShapePath.FlagsAndCommand orientation) { if (orientation != ShapePath.FlagsAndCommand.FlagNone) { int start = 0; while (start < vertices.total_vertices()) { start = arrange_orientations(start, orientation); } } }
public ContourGenerator() { m_stroker = new StrokeMath(); m_width = 1; m_src_vertices = new VertexSequence(); m_out_vertices = new Vector2Container(); m_status = StrokeMath.status_e.initial; m_src_vertex = 0; m_closed = false; m_orientation = 0; m_auto_detect = false; }
public ContourGenerator() { m_stroker = new StrokeMath(); m_width = 1; m_src_vertices = new VertexSequence(); m_out_vertices = new Vector2Container(); m_status = StrokeMath.status_e.initial; m_src_vertex = 0; m_closed = false; m_orientation = 0; m_auto_detect = false; }
public IEnumerable <VertexData> Vertices() { rewind(0); ShapePath.FlagsAndCommand command = ShapePath.FlagsAndCommand.CommandStop; do { double x; double y; command = vertex(out x, out y); yield return(new VertexData(command, new Vector2(x, y))); } while (command != ShapePath.FlagsAndCommand.CommandStop); }
public void flip_y(double y1, double y2) { int i; double x, y; for (i = 0; i < vertices.total_vertices(); i++) { ShapePath.FlagsAndCommand PathAndFlags = vertices.vertex(i, out x, out y); if (ShapePath.is_vertex(PathAndFlags)) { vertices.modify_vertex(i, x, y2 - y + y1); } } }
// Flip all vertices horizontally or vertically, // between x1 and x2, or between y1 and y2 respectively //-------------------------------------------------------------------- public void flip_x(double x1, double x2) { int i; double x, y; for (i = 0; i < vertexDataManager.total_vertices(); i++) { ShapePath.FlagsAndCommand PathAndFlags = vertexDataManager.vertex(i, out x, out y); if (ShapePath.is_vertex(PathAndFlags)) { vertexDataManager.modify_vertex(i, x2 - x + x1, y); } } }
public ShapePath.FlagsAndCommand vertex(out double x, out double y) { if (currentEnumerator == null) { rewind(0); } x = currentEnumerator.Current.position.X; y = currentEnumerator.Current.position.Y; ShapePath.FlagsAndCommand command = currentEnumerator.Current.command; currentEnumerator.MoveNext(); return(command); }
/* * public void arc_to(double rx, double ry, * double angle, * bool large_arc_flag, * bool sweep_flag, * double x, double y) * { * if(m_vertices.total_vertices() && is_vertex(m_vertices.last_command())) * { * double epsilon = 1e-30; * double x0 = 0.0; * double y0 = 0.0; * m_vertices.last_vertex(&x0, &y0); * * rx = fabs(rx); * ry = fabs(ry); * * // Ensure radii are valid * //------------------------- * if(rx < epsilon || ry < epsilon) * { * line_to(x, y); * return; * } * * if(calc_distance(x0, y0, x, y) < epsilon) * { * // If the endpoints (x, y) and (x0, y0) are identical, then this * // is equivalent to omitting the elliptical arc segment entirely. * return; * } * bezier_arc_svg a(x0, y0, rx, ry, angle, large_arc_flag, sweep_flag, x, y); * if(a.radii_ok()) * { * join_path(a); * } * else * { * line_to(x, y); * } * } * else * { * move_to(x, y); * } * } * * public void arc_rel(double rx, double ry, * double angle, * bool large_arc_flag, * bool sweep_flag, * double dx, double dy) * { * rel_to_abs(&dx, &dy); * arc_to(rx, ry, angle, large_arc_flag, sweep_flag, dx, dy); * } */ public IEnumerable <VertexData> Vertices() { int count = vertices.total_vertices(); for (int i = 0; i < count; i++) { double x = 0; double y = 0; ShapePath.FlagsAndCommand command = vertices.vertex(i, out x, out y); yield return(new VertexData(command, new Vector2(x, y))); } yield return(new VertexData(ShapePath.FlagsAndCommand.CommandStop, new Vector2(0, 0))); }
public ShapePath.FlagsAndCommand vertex(out double x, out double y) { if (!ShapePath.is_stop(m_curve3.vertex(out x, out y))) { lastX = x; lastY = y; return(ShapePath.FlagsAndCommand.CommandLineTo); } if (!ShapePath.is_stop(m_curve4.vertex(out x, out y))) { lastX = x; lastY = y; return(ShapePath.FlagsAndCommand.CommandLineTo); } double ct2_x; double ct2_y; double end_x; double end_y; ShapePath.FlagsAndCommand cmd = VertexSource.vertex(out x, out y); switch (cmd) { case ShapePath.FlagsAndCommand.CommandCurve3: VertexSource.vertex(out end_x, out end_y); m_curve3.init(lastX, lastY, x, y, end_x, end_y); m_curve3.vertex(out x, out y); // First call returns path_cmd_move_to m_curve3.vertex(out x, out y); // This is the first vertex of the curve cmd = ShapePath.FlagsAndCommand.CommandLineTo; break; case ShapePath.FlagsAndCommand.CommandCurve4: VertexSource.vertex(out ct2_x, out ct2_y); VertexSource.vertex(out end_x, out end_y); m_curve4.init(lastX, lastY, x, y, ct2_x, ct2_y, end_x, end_y); m_curve4.vertex(out x, out y); // First call returns path_cmd_move_to m_curve4.vertex(out x, out y); // This is the first vertex of the curve cmd = ShapePath.FlagsAndCommand.CommandLineTo; break; } lastX = x; lastY = y; return(cmd); }
public int arrange_orientations(int start, ShapePath.FlagsAndCommand orientation) { if (orientation != ShapePath.FlagsAndCommand.FlagNone) { while (start < vertices.total_vertices()) { start = arrange_polygon_orientation(start, orientation); if (ShapePath.is_stop(vertices.command(start))) { ++start; break; } } } return(start); }
public void join_path(PathStorage vs, int path_id) { double x, y; vs.rewind(path_id); ShapePath.FlagsAndCommand PathAndFlags = vs.vertex(out x, out y); if (!ShapePath.is_stop(PathAndFlags)) { if (ShapePath.is_vertex(PathAndFlags)) { double x0, y0; ShapePath.FlagsAndCommand PathAndFlags0 = last_vertex(out x0, out y0); if (ShapePath.is_vertex(PathAndFlags0)) { if (agg_math.calc_distance(x, y, x0, y0) > agg_math.vertex_dist_epsilon) { if (ShapePath.is_move_to(PathAndFlags)) { PathAndFlags = ShapePath.FlagsAndCommand.CommandLineTo; } vertices.AddVertex(x, y, PathAndFlags); } } else { if (ShapePath.is_stop(PathAndFlags0)) { PathAndFlags = ShapePath.FlagsAndCommand.CommandMoveTo; } else { if (ShapePath.is_move_to(PathAndFlags)) { PathAndFlags = ShapePath.FlagsAndCommand.CommandLineTo; } } vertices.AddVertex(x, y, PathAndFlags); } } while (!ShapePath.is_stop(PathAndFlags = vs.vertex(out x, out y))) { vertices.AddVertex(x, y, ShapePath.is_move_to(PathAndFlags) ? ShapePath.FlagsAndCommand.CommandLineTo : PathAndFlags); } } }
// Arrange the orientation of a polygon, all polygons in a path, // or in all paths. After calling arrange_orientations() or // arrange_orientations_all_paths(), all the polygons will have // the same orientation, i.e. path_flags_cw or path_flags_ccw //-------------------------------------------------------------------- public int arrange_polygon_orientation(int start, ShapePath.FlagsAndCommand orientation) { if (orientation == ShapePath.FlagsAndCommand.FlagNone) { return(start); } // Skip all non-vertices at the beginning while (start < vertices.total_vertices() && !ShapePath.is_vertex(vertices.command(start))) { ++start; } // Skip all insignificant move_to while (start + 1 < vertices.total_vertices() && ShapePath.is_move_to(vertices.command(start)) && ShapePath.is_move_to(vertices.command(start + 1))) { ++start; } // Find the last vertex int end = start + 1; while (end < vertices.total_vertices() && !ShapePath.is_next_poly(vertices.command(end))) { ++end; } if (end - start > 2) { if (perceive_polygon_orientation(start, end) != orientation) { // Invert polygon, set orientation flag, and skip all end_poly invert_polygon(start, end); ShapePath.FlagsAndCommand PathAndFlags; while (end < vertices.total_vertices() && ShapePath.is_end_poly(PathAndFlags = vertices.command(end))) { vertices.modify_command(end++, PathAndFlags | orientation); // Path.set_orientation(cmd, orientation)); } } } return(end); }
void add_vertex(double x, double y, ShapePath.FlagsAndCommand cmd) { if (ShapePath.is_move_to(cmd)) { move_to_d(x, y); } else if (ShapePath.is_vertex(cmd)) { line_to_d(x, y); } else if (ShapePath.is_close(cmd)) { m_VectorClipper.line_to(m_Rasterizer, m_start_x, m_start_y); } }
public ImageBuffer GetImageForCharacter(char character, double xFraction, double yFraction, RGBA_Bytes color) { if (xFraction > 1 || xFraction < 0 || yFraction > 1 || yFraction < 0) { throw new ArgumentException("The x and y fractions must both be between 0 and 1."); } ImageBuffer imageForCharacter; Dictionary <char, ImageBuffer> characterImageCache = StyledTypeFaceImageCache.GetCorrectCache(this.TypeFace, color, this.emSizeInPixels); characterImageCache.TryGetValue(character, out imageForCharacter); if (imageForCharacter != null) { return(imageForCharacter); } IVertexSource glyphForCharacter = GetGlyphForCharacter(character); if (glyphForCharacter == null) { return(null); } glyphForCharacter.rewind(0); double x, y; ShapePath.FlagsAndCommand curCommand = glyphForCharacter.vertex(out x, out y); RectangleDouble bounds = new RectangleDouble(x, y, x, y); while (curCommand != ShapePath.FlagsAndCommand.CommandStop) { bounds.ExpandToInclude(x, y); curCommand = glyphForCharacter.vertex(out x, out y); } int descentExtraHeight = (int)(-DescentInPixels + .5); ImageBuffer charImage = new ImageBuffer(Math.Max((int)(bounds.Width + .5), 1) + 1, Math.Max((int)(EmSizeInPixels + descentExtraHeight + .5), 1) + 1, 32, new BlenderPreMultBGRA()); charImage.OriginOffset = new VectorMath.Vector2(0, descentExtraHeight); Graphics2D graphics = charImage.NewGraphics2D(); graphics.Render(glyphForCharacter, xFraction, yFraction + descentExtraHeight, color); characterImageCache[character] = charImage; return(charImage); }
public override ShapePath.FlagsAndCommand vertex(out double x, out double y) { x = 0; y = 0; ShapePath.FlagsAndCommand cmd = ShapePath.FlagsAndCommand.CommandLineTo; switch (m_idx) { case 0: cmd = m_curve_poly.vertex(out x, out y); break; case 1: if (m_vertex == 0 || m_vertex == 4 || m_vertex == 8 || m_vertex == 14) { cmd = ShapePath.FlagsAndCommand.CommandMoveTo; } if (m_vertex >= 20) { cmd = ShapePath.FlagsAndCommand.CommandStop; } x = gridVertexX[m_vertex]; y = gridVertexY[m_vertex]; m_vertex++; break; case 2: // Point1 case 3: // Point2 cmd = m_ellipse.vertex(out x, out y); break; case 4: cmd = m_text_poly.vertex(out x, out y); break; default: cmd = ShapePath.FlagsAndCommand.CommandStop; break; } return(cmd); }
public static void SendShapeToTesselator(VertexTesselatorAbstract tesselator, IVertexSource vertexSource) { #if !DEBUG try #endif { tesselator.BeginPolygon(); ShapePath.FlagsAndCommand PathAndFlags = 0; double x, y; bool haveBegunContour = false; while (!ShapePath.is_stop(PathAndFlags = vertexSource.vertex(out x, out y))) { if (ShapePath.is_close(PathAndFlags) || (haveBegunContour && ShapePath.is_move_to(PathAndFlags))) { tesselator.EndContour(); haveBegunContour = false; } if (!ShapePath.is_close(PathAndFlags)) { if (!haveBegunContour) { tesselator.BeginContour(); haveBegunContour = true; } tesselator.AddVertex(x, y); } } if (haveBegunContour) { tesselator.EndContour(); } tesselator.EndPolygon(); } #if !DEBUG catch { } #endif }
private void allocate_if_required(int indexToAdd) { if (indexToAdd < m_num_vertices) { return; } while (indexToAdd >= m_allocated_vertices) { int newSize = m_allocated_vertices + 256; double[] newX = new double[newSize]; double[] newY = new double[newSize]; ShapePath.FlagsAndCommand[] newCmd = new ShapePath.FlagsAndCommand[newSize]; if (m_coord_x != null) { for (int i = 0; i < m_num_vertices; i++) { newX[i] = m_coord_x[i]; newY[i] = m_coord_y[i]; newCmd[i] = m_CommandAndFlags[i]; } } m_coord_x = newX; m_coord_y = newY; m_CommandAndFlags = newCmd; m_allocated_vertices = newSize; } }
public ShapePath.FlagsAndCommand vertex(out double x, out double y) { x = 0; y = 0; ShapePath.FlagsAndCommand command = ShapePath.FlagsAndCommand.CommandStop; bool done = false; while (!done) { switch (m_status) { case status.initial: markers.remove_all(); m_last_cmd = VertexSource.vertex(out m_start_x, out m_start_y); m_status = status.accumulate; goto case status.accumulate; case status.accumulate: if (ShapePath.is_stop(m_last_cmd)) { return ShapePath.FlagsAndCommand.CommandStop; } generator.RemoveAll(); generator.AddVertex(m_start_x, m_start_y, ShapePath.FlagsAndCommand.CommandMoveTo); markers.add_vertex(m_start_x, m_start_y, ShapePath.FlagsAndCommand.CommandMoveTo); for (; ; ) { command = VertexSource.vertex(out x, out y); //DebugFile.Print("x=" + x.ToString() + " y=" + y.ToString() + "\n"); if (ShapePath.is_vertex(command)) { m_last_cmd = command; if (ShapePath.is_move_to(command)) { m_start_x = x; m_start_y = y; break; } generator.AddVertex(x, y, command); markers.add_vertex(x, y, ShapePath.FlagsAndCommand.CommandLineTo); } else { if (ShapePath.is_stop(command)) { m_last_cmd = ShapePath.FlagsAndCommand.CommandStop; break; } if (ShapePath.is_end_poly(command)) { generator.AddVertex(x, y, command); break; } } } generator.Rewind(0); m_status = status.generate; goto case status.generate; case status.generate: command = generator.Vertex(ref x, ref y); //DebugFile.Print("x=" + x.ToString() + " y=" + y.ToString() + "\n"); if (ShapePath.is_stop(command)) { m_status = status.accumulate; break; } done = true; break; } } return command; }
public void AddVertex(double x, double y, ShapePath.FlagsAndCommand cmd) { m_status = StrokeMath.status_e.initial; if (ShapePath.is_move_to(cmd)) { m_src_vertices.modify_last(new VertexDistance(x, y)); } else { if (ShapePath.is_vertex(cmd)) { m_src_vertices.add(new VertexDistance(x, y)); } else { if (ShapePath.is_end_poly(cmd)) { m_closed = (ShapePath.get_close_flag(cmd) == ShapePath.FlagsAndCommand.FlagClose); if (m_orientation == ShapePath.FlagsAndCommand.FlagNone) { m_orientation = ShapePath.get_orientation(cmd); } } } } }
// Vertex Source Interface public void Rewind(int idx) { if (m_status == StrokeMath.status_e.initial) { m_src_vertices.close(true); if (m_auto_detect) { if (!ShapePath.is_oriented(m_orientation)) { m_orientation = (agg_math.calc_polygon_area(m_src_vertices) > 0.0) ? ShapePath.FlagsAndCommand.FlagCCW : ShapePath.FlagsAndCommand.FlagCW; } } if (ShapePath.is_oriented(m_orientation)) { m_stroker.width(ShapePath.is_ccw(m_orientation) ? m_width : -m_width); } } m_status = StrokeMath.status_e.ready; m_src_vertex = 0; }