org.nanes.slideset.dm.read

Class SVGFileToIJ1ROIReader

java.lang.Object

org.nanes.slideset.dm.read.SVGFileToIJ1ROIReader

All Implemented Interfaces:

ElementReader<FileLinkElement,ij.gui.Roi[]>

@ElementReaderMetadata(name="ROI set file (SVG)",
                       elementType=FileLinkElement.class,
                       mimeTypes="image/svg+xml",
                       processedType=RoisAlias.class,
                       hidden=false)
public class SVGFileToIJ1ROIReader
extends Object
implements ElementReader<FileLinkElement,ij.gui.Roi[]>

Read ImageJ1-style ROIs from an SVG file.

Author:

Benjamin Nanes

Field Summary

Fields

Modifier and Type	Field and Description
private org.scijava.Context	ij
private String	warningMessage

Constructor Summary

Constructors

Constructor and Description
SVGFileToIJ1ROIReader()

Method Summary

Modifier and Type	Method and Description
private ij.gui.Roi	arcAsEllipse(String code, String param, double[] start, String pathData, Element n) Attempt to generate an ellipse ROI from an arc path
private int	getFirstPathInstructionEnd(String pathData) Get the end index of the first path data instruction in pathData.
private int	getFirstTransformEnd(String transformList) Get the index of the end of the first transform string in a transform attribute list.
private ArrayList<String>	listPathInstructions(String pathData) Make a path data String into a convenient List!
private Document	loadDocument(File file) Load the DOM from an SVG file
private ij.gui.Roi	makeEllipseOverlay(double cx, double cy, double rx, double ry, Element element) Generate an ROI from parsed ellipse data
private ij.gui.OvalRoi	parseCircle(Element n) Generate an ROI from a circle element
private ArrayList<ij.gui.Roi>	parseDocument(Document dom) Get the list of ROIs that can be created from the DOM
private ij.gui.Roi	parseEllipse(Element n) Generate an ROI from an ellipse element
private double	parseLength(String length) Parse an SVG length String (possibly with units), and convert to pixels
private ij.gui.Roi	parseLine(Element n) Generate an ROI from a line element.
private ArrayList<Double>	parseListOfNumbers(String list) Parse a list of numbers, possibly with units
private ArrayList<double[]>	parseListOfPoints(String list) Parse a list of points, as used in polygon and polyline elements
private ij.gui.Roi	parseNode(Node n) Generate an overlay from an SVG node
private ij.gui.Roi	parsePath(Element n) Generate an ROI from a path element May return a different type of ROI, depending on the data:
private ij.gui.PolygonRoi	parsePolygon(Element n) Generate an ROI from a polygon element
private ij.gui.PolygonRoi	parsePolyline(Element n) Generate an ROI from a polyline element
private ij.gui.Roi	parseRect(Element n) Generate an ROI from a rect element
private double[]	parseTransform(double[] point, String transform) Transform a coordinate pair
ij.gui.Roi[]	read(FileLinkElement elementToRead) Convert "underlying" data to "processed" data.
private double[]	reflect(double[] a, double[] b) Point a reflected about point b
private double[]	transformMatrix(double[] point, double[] matrix) Apply a matrix transformation.
private double[]	transformRotate(double[] point, double a) Apply a rotation about the origin
private double[]	transformRotate(double[] point, double a, double cx, double cy) Apply a rotation about center point {cx,cy}
private double[]	transformScale(double[] point, double sx, double sy) Apply a scale
private double[]	transformSkewX(double[] point, double a) Skew along the x-axis
private double[]	transformSkewY(double[] point, double a) Skew along the y-axis
private double[]	transformToDocumentSpace(double[] point, Node n) Transform a point ({x,y}) to document space by recursively looking for transform attributes in the given nodes and all parent nodes.
private double[]	transformTranslate(double[] point, double tx, double ty) Apply a translation
private double[]	vectorAdd(double[] a, double[] b) Vectorized add function
private double[]	vectorNegate(double[] a) Multiply a vector by -I

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

ij

private org.scijava.Context ij

warningMessage

private String warningMessage

Constructor Detail

SVGFileToIJ1ROIReader

public SVGFileToIJ1ROIReader()

Method Detail

read

public ij.gui.Roi[] read(FileLinkElement elementToRead)
                  throws SlideSetException

Description copied from interface: ElementReader

Convert "underlying" data to "processed" data.

Specified by:

read in interface ElementReader<FileLinkElement,ij.gui.Roi[]>

Parameters:

elementToRead - The DataElement containing the "underlying" data which should be translated.

Returns:

The "processed" data.

Throws:

SlideSetException

loadDocument

private Document loadDocument(File file)
                       throws SlideSetException

Load the DOM from an SVG file

Throws:

SlideSetException

parseDocument

private ArrayList<ij.gui.Roi> parseDocument(Document dom)

Get the list of ROIs that can be created from the DOM

parseNode

private ij.gui.Roi parseNode(Node n)
                      throws SVGParseException

Generate an overlay from an SVG node

Parameters:

n - The node

Returns:

The overlay, or null if an overlay cannot be created from the node

Throws:

SVGParseException

parsePolyline

private ij.gui.PolygonRoi parsePolyline(Element n)
                                 throws SVGParseException

Generate an ROI from a polyline element

Throws:

SVGParseException

parsePolygon

private ij.gui.PolygonRoi parsePolygon(Element n)
                                throws SVGParseException

Generate an ROI from a polygon element

Throws:

SVGParseException

parseLine

private ij.gui.Roi parseLine(Element n)
                      throws SVGParseException

Generate an ROI from a line element. Lines with the same start and end points will generate point overlays.

Throws:

SVGParseException

parseCircle

private ij.gui.OvalRoi parseCircle(Element n)
                            throws SVGParseException

Generate an ROI from a circle element

Throws:

SVGParseException

parseEllipse

private ij.gui.Roi parseEllipse(Element n)
                         throws SVGParseException

Generate an ROI from an ellipse element

Throws:

SVGParseException

makeEllipseOverlay

private ij.gui.Roi makeEllipseOverlay(double cx,
                                      double cy,
                                      double rx,
                                      double ry,
                                      Element element)
                               throws SVGParseException

Generate an ROI from parsed ellipse data

Throws:

SVGParseException

parseRect

private ij.gui.Roi parseRect(Element n)
                      throws SVGParseException

Generate an ROI from a rect element

Throws:

SVGParseException

parsePath

private ij.gui.Roi parsePath(Element n)
                      throws SVGParseException

Generate an ROI from a path element May return a different type of ROI, depending on the data:

Throws:

SVGParseException

arcAsEllipse

private ij.gui.Roi arcAsEllipse(String code,
                                String param,
                                double[] start,
                                String pathData,
                                Element n)
                         throws SVGParseException

Attempt to generate an ellipse ROI from an arc path

Throws:

SVGParseException

reflect

private double[] reflect(double[] a,
                         double[] b)

Point a reflected about point b

vectorAdd

private double[] vectorAdd(double[] a,
                           double[] b)

Vectorized add function

vectorNegate

private double[] vectorNegate(double[] a)

Multiply a vector by -I

listPathInstructions

private ArrayList<String> listPathInstructions(String pathData)
                                        throws SVGParseException

Make a path data String into a convenient List!

Throws:

SVGParseException

getFirstPathInstructionEnd

private int getFirstPathInstructionEnd(String pathData)

Get the end index of the first path data instruction in pathData. Does not really verify that the instruction is correctly formed, but identifies the end of the instruction, assuming it is correctly formed. Note that this won't work if pathData has leading white space!

parseListOfPoints

private ArrayList<double[]> parseListOfPoints(String list)
                                       throws NumberFormatException,
                                              SVGParseException

Parse a list of points, as used in polygon and polyline elements

Returns:

A List of points: (x, y)

Throws:

NumberFormatException

SVGParseException

parseListOfNumbers

private ArrayList<Double> parseListOfNumbers(String list)
                                      throws NumberFormatException,
                                             SVGParseException

Parse a list of numbers, possibly with units

Throws:

NumberFormatException

SVGParseException

parseLength

private double parseLength(String length)
                    throws SVGParseException,
                           NumberFormatException

Parse an SVG length String (possibly with units), and convert to pixels

Throws:

SVGParseException

NumberFormatException

transformToDocumentSpace

private double[] transformToDocumentSpace(double[] point,
                                          Node n)
                                   throws SVGParseException

Transform a point ({x,y}) to document space by recursively looking for transform attributes in the given nodes and all parent nodes.

Parameters:

point -

n -

Returns:

{x,y}

Throws:

SVGParseException

getFirstTransformEnd

private int getFirstTransformEnd(String transformList)
                          throws SVGParseException

Get the index of the end of the first transform string in a transform attribute list.

Parameters:

transformList - The transform attribute value, possibly specifying a list of transforms.

Returns:

The end index of the first transform in transformList. If there are no more transforms in the list, returns 0.

Throws:

SVGParseException - If a formatting error is detected, but error detection is not guaranteed.

parseTransform

private double[] parseTransform(double[] point,
                                String transform)
                         throws SVGParseException

Transform a coordinate pair

Parameters:

point - {x,y}

transform - The transform

Returns:

{x,y}

Throws:

SVGParseException

transformMatrix

private double[] transformMatrix(double[] point,
                                 double[] matrix)

Apply a matrix transformation.

WARNING - Matrix specification (by row) differs from standard SVG order (by column)

Parameters:

point - {x,y}

matrix - {a,c,e,b,d,f}

Returns:

{x,y}

transformTranslate

private double[] transformTranslate(double[] point,
                                    double tx,
                                    double ty)

Apply a translation

Parameters:

point - {x,y}

tx - Delta x

ty - Delta y

Returns:

{x,y}

transformScale

private double[] transformScale(double[] point,
                                double sx,
                                double sy)

Apply a scale

Parameters:

point - {x,y}

sx - x scale factor

sy - y scale factor

Returns:

{x,y}

transformRotate

private double[] transformRotate(double[] point,
                                 double a)

Apply a rotation about the origin

Parameters:

point - {x,y}

a - Angle, in degrees

Returns:

{x,y}

transformRotate

private double[] transformRotate(double[] point,
                                 double a,
                                 double cx,
                                 double cy)

Apply a rotation about center point {cx,cy}

Parameters:

point - {x,y}

a - Angle, in degrees

Returns:

{x,y}

transformSkewX

private double[] transformSkewX(double[] point,
                                double a)

Skew along the x-axis

Parameters:

point - {x,y}

a - Angle, in degrees

Returns:

{x,y}

transformSkewY

private double[] transformSkewY(double[] point,
                                double a)

Skew along the y-axis

Parameters:

point - {x,y}

a - Angle, in degrees

Returns:

{x,y}