jatria-soft/esvg
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[PORT] step 1

Browse Source
This commit is contained in:
Edouard DUPIN 2021-02-22 22:08:13 +01:00
parent ef4e3be43f
commit ad5b11151e
62 changed files with 529 additions and 529 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/org/atriasoft/esvg/Base.cpp
View File

@ -19,7 +19,7 @@ esvg::PaintState::PaintState() :
lineCap(esvg::cap_butt),
lineJoin(esvg::join_miter),
miterLimit(4.0f),
viewPort(vec2(0.0f,0.0f), vec2(0.0f,0.0f)),
viewPort(Vector2f(0.0f,0.0f), Vector2f(0.0f,0.0f)),
opacity(1.0) {
}
@ -108,10 +108,10 @@ void esvg::Base::parseTransform(const exml::Element& _element) {
if (data.size() != 0) {
float xxx, yyy;
if (sscanf(data.c_str(), "%f %f", &xxx, &yyy) == 2) {
m_transformMatrix *= etk::mat2x3Translate(vec2(xxx, yyy));
m_transformMatrix *= etk::mat2x3Translate(Vector2f(xxx, yyy));
Log.verbose("Translate : " << xxx << ", " << yyy);
} else if (sscanf(data.c_str(), "%f", &xxx) == 1) {
m_transformMatrix *= etk::mat2x3Translate(vec2(xxx, 0));
m_transformMatrix *= etk::mat2x3Translate(Vector2f(xxx, 0));
Log.verbose("Translate : " << xxx << ", " << 0);
} else {
Log.error("Parsing translate() with wrong data ... '" << data << "'");
@ -121,7 +121,7 @@ void esvg::Base::parseTransform(const exml::Element& _element) {
if (data.size() != 0) {
float xxx, yyy;
if (sscanf(data.c_str(), "%f %f", &xxx, &yyy) == 2) {
m_transformMatrix *= etk::mat2x3Scale(vec2(xxx, yyy));
m_transformMatrix *= etk::mat2x3Scale(Vector2f(xxx, yyy));
Log.verbose("Scale : " << xxx << ", " << yyy);
} else if (sscanf(data.c_str(), "%f", &xxx) == 1) {
m_transformMatrix *= etk::mat2x3Scale(xxx);
@ -135,9 +135,9 @@ void esvg::Base::parseTransform(const exml::Element& _element) {
float angle, xxx, yyy;
if (sscanf(data.c_str(), "%f %f %f", &angle, &xxx, &yyy) == 3) {
angle = angle / 180 * M_PI;
m_transformMatrix *= etk::mat2x3Translate(vec2(-xxx, -yyy));
m_transformMatrix *= etk::mat2x3Translate(Vector2f(-xxx, -yyy));
m_transformMatrix *= etk::mat2x3Rotate(angle);
m_transformMatrix *= etk::mat2x3Translate(vec2(xxx, yyy));
m_transformMatrix *= etk::mat2x3Translate(Vector2f(xxx, yyy));
} else if (sscanf(data.c_str(), "%f", &angle) == 1) {
angle = angle / 180 * M_PI;
Log.verbose("rotate : " << angle << "rad, " << (angle/M_PI*180) << "°");
@ -152,7 +152,7 @@ void esvg::Base::parseTransform(const exml::Element& _element) {
if (sscanf(data.c_str(), "%f", &angle) == 1) {
angle = angle / 180 * M_PI;
Log.verbose("skewX : " << angle << "rad, " << (angle/M_PI*180) << "°");
m_transformMatrix *= etk::mat2x3Skew(vec2(angle, 0.0f));
m_transformMatrix *= etk::mat2x3Skew(Vector2f(angle, 0.0f));
} else {
Log.error("Parsing skewX() with wrong data ... '" << data << "'");
}
@ -163,14 +163,14 @@ void esvg::Base::parseTransform(const exml::Element& _element) {
if (sscanf(data.c_str(), "%f", &angle) == 1) {
angle = angle / 180 * M_PI;
Log.verbose("skewY : " << angle << "rad, " << (angle/M_PI*180) << "°");
m_transformMatrix *= etk::mat2x3Skew(vec2(0.0f, angle));
m_transformMatrix *= etk::mat2x3Skew(Vector2f(0.0f, angle));
} else {
Log.error("Parsing skewY() with wrong data ... '" << data << "'");
}
}
}
void esvg::Base::parsePosition(const exml::Element& _element, vec2 &_pos, vec2 &_size) {
void esvg::Base::parsePosition(const exml::Element& _element, Vector2f &_pos, Vector2f &_size) {
_pos.setValue(0,0);
_size.setValue(0,0);
@ -307,7 +307,7 @@ void esvg::Base::parsePaintAttr(const exml::Element& _element) {
if (content == "none" ) {
// OK, Nothing to do ...
} else {
ESVG_TODO(" 'stroke-dasharray' not implemented ...");
Log.todo(" 'stroke-dasharray' not implemented ...");
}
}
content = _element.attributes["stroke-linecap"];
@ -396,11 +396,11 @@ etk::Pair<etk::Color<float,4>, etk::String> esvg::Base::parseColor(const etk::St
return localColor;
}
bool esvg::Base::parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::Base::parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
// TODO : UNDERSTAND why nothing is done here ...
// Parse basic elements (ID...):
m_id = _element.attributes["id"];
_sizeMax = vec2(0.0f, 0.0f);
_sizeMax = Vector2f(0.0f, 0.0f);
return false;
}
@ -429,7 +429,7 @@ void esvg::Base::setId(const etk::String& _newId) {
}
void esvg::Base::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void esvg::Base::drawShapePoints(List<etk::Vector<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

8
src/org/atriasoft/esvg/Base.java
View File

@ -45,7 +45,7 @@ namespace esvg {
enum esvg::cap lineCap;
enum esvg::join lineJoin;
float miterLimit;
etk::Pair<vec2, vec2> viewPort; //!< min pos, max pos
etk::Pair<Vector2f, Vector2f> viewPort; //!< min pos, max pos
float opacity;
};
@ -63,7 +63,7 @@ namespace esvg {
* @param[in] _element standart XML node
* @return true if no problem arrived
*/
virtual bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax);
virtual bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax);
/**
* @brief Draw the form in the renderer
* @param[in] _myRenderer Renderer engine
@ -79,7 +79,7 @@ namespace esvg {
* @param[in] _basicTrans Parant transformation of the environement
* @param[in] _level Level of the tree
*/
virtual void drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
virtual void drawShapePoints(List<List<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,
@ -93,7 +93,7 @@ namespace esvg {
* @param[out] _pos parsed position
* @param[out] _size parsed dimention
*/
void parsePosition(const exml::Element& _element, vec2 &_pos, vec2 &_size);
void parsePosition(const exml::Element& _element, Vector2f &_pos, Vector2f &_size);
/**
* @brief parse a lenght of the xml element
* @param[in] _dataInput Data C String with the printed lenght

32
src/org/atriasoft/esvg/Circle.cpp
View File

@ -17,7 +17,7 @@ esvg::Circle::~Circle() {
}
bool esvg::Circle::parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::Circle::parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
m_radius = 0.0;
m_position.setValue(0,0);
if (_element.exist() == false) {
@ -61,23 +61,23 @@ esvg::render::Path esvg::Circle::createPath() {
esvg::render::Path out;
out.clear();
out.moveTo(false, m_position + vec2(m_radius, 0.0f));
out.moveTo(false, m_position + Vector2f(m_radius, 0.0f));
out.curveTo(false,
m_position + vec2(m_radius, m_radius*esvg::kappa90),
m_position + vec2(m_radius*esvg::kappa90, m_radius),
m_position + vec2(0.0f, m_radius));
m_position + Vector2f(m_radius, m_radius*esvg::kappa90),
m_position + Vector2f(m_radius*esvg::kappa90, m_radius),
m_position + Vector2f(0.0f, m_radius));
out.curveTo(false,
m_position + vec2(-m_radius*esvg::kappa90, m_radius),
m_position + vec2(-m_radius, m_radius*esvg::kappa90),
m_position + vec2(-m_radius, 0.0f));
m_position + Vector2f(-m_radius*esvg::kappa90, m_radius),
m_position + Vector2f(-m_radius, m_radius*esvg::kappa90),
m_position + Vector2f(-m_radius, 0.0f));
out.curveTo(false,
m_position + vec2(-m_radius, -m_radius*esvg::kappa90),
m_position + vec2(-m_radius*esvg::kappa90, -m_radius),
m_position + vec2(0.0f, -m_radius));
m_position + Vector2f(-m_radius, -m_radius*esvg::kappa90),
m_position + Vector2f(-m_radius*esvg::kappa90, -m_radius),
m_position + Vector2f(0.0f, -m_radius));
out.curveTo(false,
m_position + vec2(m_radius*esvg::kappa90, -m_radius),
m_position + vec2(m_radius, -m_radius*esvg::kappa90),
m_position + vec2(m_radius, 0.0f));
m_position + Vector2f(m_radius*esvg::kappa90, -m_radius),
m_position + Vector2f(m_radius, -m_radius*esvg::kappa90),
m_position + Vector2f(m_radius, 0.0f));
out.close();
return out;
}
@ -143,7 +143,7 @@ void esvg::Circle::draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_
#endif
}
void esvg::Circle::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void esvg::Circle::drawShapePoints(List<etk::Vector<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,
@ -156,7 +156,7 @@ void esvg::Circle::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
listPoints = listElement.generateListPoints(_level, _recurtionMax, _threshold);
listPoints.applyMatrix(mtx);
for (auto &it : listPoints.m_data) {
etk::Vector<vec2> listPoint;
List<Vector2f> listPoint;
for (auto &itDot : it) {
listPoint.pushBack(itDot.m_pos);
}

6
src/org/atriasoft/esvg/Circle.java
View File

@ -10,15 +10,15 @@
namespace esvg {
class Circle : public esvg::Base {
private:
vec2 m_position; //!< Position of the Circle
Vector2f m_position; //!< Position of the Circle
float m_radius; //!< Radius of the Circle
public:
Circle(PaintState _parentPaintState);
~Circle();
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) override;
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) override;
void display(int32_t _spacing) override;
void draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t _level) override;
void drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void drawShapePoints(List<List<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

26
src/org/atriasoft/esvg/Dimension.cpp
View File

@ -27,7 +27,7 @@ esvg::Dimension::Dimension() :
// notinh to do ...
}
esvg::Dimension::Dimension(const vec2& _size, enum esvg::distance _type) :
esvg::Dimension::Dimension(const Vector2f& _size, enum esvg::distance _type) :
m_data(0,0),
m_type(esvg::distance_pixel) {
set(_size, _type);
@ -66,7 +66,7 @@ void esvg::Dimension::set(etk::String _config) {
Log.verbose("default dimention type for: '" << _config << "' ==> pixel");
return;
}
vec2 tmp = _config;
Vector2f tmp = _config;
set(tmp, type);
Log.verbose(" config dimention : \"" << _config << "\" == > " << *this );
}
@ -116,7 +116,7 @@ void esvg::Dimension::set(etk::String _configX, etk::String _configY) {
enum distance typeY = parseType(_configY);
float valueY = etk::string_to_float(_configY);
// TODO : Check difference ...
set(vec2(valueX, valueY), typeX);
set(Vector2f(valueX, valueY), typeX);
Log.verbose(" config dimention : '" << _configX << "' '" << _configY << "' == > " << *this );
}
@ -169,7 +169,7 @@ esvg::Dimension::operator etk::String() const {
return str;
}
void esvg::Dimension::set(const vec2& _size, enum esvg::distance _type) {
void esvg::Dimension::set(const Vector2f& _size, enum esvg::distance _type) {
m_data = _size;
m_type = _type;
switch(_type) {
@ -192,26 +192,26 @@ void esvg::Dimension::set(const vec2& _size, enum esvg::distance _type) {
}
}
vec2 esvg::Dimension::getPixel(const vec2& _upperSize) const {
Vector2f esvg::Dimension::getPixel(const Vector2f& _upperSize) const {
switch(m_type) {
case esvg::distance_pourcent:
return vec2(_upperSize.x()*m_data.x()*0.01f, _upperSize.y()*m_data.y()*0.01f);
return Vector2f(_upperSize.x()*m_data.x()*0.01f, _upperSize.y()*m_data.y()*0.01f);
case esvg::distance_pixel:
return m_data;
case esvg::distance_meter:
return vec2(m_data.x()*meterToMillimeter*basicRatio, m_data.y()*meterToMillimeter*basicRatio);
return Vector2f(m_data.x()*meterToMillimeter*basicRatio, m_data.y()*meterToMillimeter*basicRatio);
case esvg::distance_centimeter:
return vec2(m_data.x()*centimeterToMillimeter*basicRatio, m_data.y()*centimeterToMillimeter*basicRatio);
return Vector2f(m_data.x()*centimeterToMillimeter*basicRatio, m_data.y()*centimeterToMillimeter*basicRatio);
case esvg::distance_millimeter:
return vec2(m_data.x()*basicRatio, m_data.y()*basicRatio);
return Vector2f(m_data.x()*basicRatio, m_data.y()*basicRatio);
case esvg::distance_kilometer:
return vec2(m_data.x()*kilometerToMillimeter*basicRatio, m_data.y()*kilometerToMillimeter*basicRatio);
return Vector2f(m_data.x()*kilometerToMillimeter*basicRatio, m_data.y()*kilometerToMillimeter*basicRatio);
case esvg::distance_inch:
return vec2(m_data.x()*inchToMillimeter*basicRatio, m_data.y()*inchToMillimeter*basicRatio);
return Vector2f(m_data.x()*inchToMillimeter*basicRatio, m_data.y()*inchToMillimeter*basicRatio);
case esvg::distance_foot:
return vec2(m_data.x()*footToMillimeter*basicRatio, m_data.y()*footToMillimeter*basicRatio);
return Vector2f(m_data.x()*footToMillimeter*basicRatio, m_data.y()*footToMillimeter*basicRatio);
}
return vec2(128.0f, 128.0f);
return Vector2f(128.0f, 128.0f);
}
etk::Stream& esvg::operator <<(etk::Stream& _os, enum esvg::distance _obj) {

10
src/org/atriasoft/esvg/Dimension.java
View File

@ -29,7 +29,7 @@ namespace esvg {
*/
class Dimension {
private:
vec2 m_data;
Vector2f m_data;
enum distance m_type;
public:
/**
@ -41,7 +41,7 @@ namespace esvg {
* @param[in] _size Requested dimention
* @param[in] _type Unit of the Dimention
*/
Dimension(const vec2& _size, enum esvg::distance _type=esvg::distance_pixel);
Dimension(const Vector2f& _size, enum esvg::distance _type=esvg::distance_pixel);
/**
* @brief Constructor
* @param[in] _config dimension configuration.
@ -75,7 +75,7 @@ namespace esvg {
* @brief get the current dimention.
* @return dimention requested.
*/
const vec2& getValue() const {
const Vector2f& getValue() const {
return m_data;
}
/**
@ -90,7 +90,7 @@ namespace esvg {
* @param[in] _size Dimention to set
* @param[in] _type Type of unit requested.
*/
void set(const vec2& _size, enum distance _type);
void set(const Vector2f& _size, enum distance _type);
public:
/**
@ -110,7 +110,7 @@ namespace esvg {
* @param[in] _upperSize Size in pixel of the upper value
* @return dimention in Pixel
*/
vec2 getPixel(const vec2& _upperSize) const;
Vector2f getPixel(const Vector2f& _upperSize) const;
/*****************************************************
* = assigment
*****************************************************/

32
src/org/atriasoft/esvg/Ellipse.cpp
View File

@ -17,7 +17,7 @@ esvg::Ellipse::~Ellipse() {
}
bool esvg::Ellipse::parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::Ellipse::parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
if (_element.exist() == false) {
return false;
}
@ -65,23 +65,23 @@ void esvg::Ellipse::display(int32_t _spacing) {
esvg::render::Path esvg::Ellipse::createPath() {
esvg::render::Path out;
out.clear();
out.moveTo(false, m_c + vec2(m_r.x(), 0.0f));
out.moveTo(false, m_c + Vector2f(m_r.x(), 0.0f));
out.curveTo(false,
m_c + vec2(m_r.x(), m_r.y()*esvg::kappa90),
m_c + vec2(m_r.x()*esvg::kappa90, m_r.y()),
m_c + vec2(0.0f, m_r.y()));
m_c + Vector2f(m_r.x(), m_r.y()*esvg::kappa90),
m_c + Vector2f(m_r.x()*esvg::kappa90, m_r.y()),
m_c + Vector2f(0.0f, m_r.y()));
out.curveTo(false,
m_c + vec2(-m_r.x()*esvg::kappa90, m_r.y()),
m_c + vec2(-m_r.x(), m_r.y()*esvg::kappa90),
m_c + vec2(-m_r.x(), 0.0f));
m_c + Vector2f(-m_r.x()*esvg::kappa90, m_r.y()),
m_c + Vector2f(-m_r.x(), m_r.y()*esvg::kappa90),
m_c + Vector2f(-m_r.x(), 0.0f));
out.curveTo(false,
m_c + vec2(-m_r.x(), -m_r.y()*esvg::kappa90),
m_c + vec2(-m_r.x()*esvg::kappa90, -m_r.y()),
m_c + vec2(0.0f, -m_r.y()));
m_c + Vector2f(-m_r.x(), -m_r.y()*esvg::kappa90),
m_c + Vector2f(-m_r.x()*esvg::kappa90, -m_r.y()),
m_c + Vector2f(0.0f, -m_r.y()));
out.curveTo(false,
m_c + vec2(m_r.x()*esvg::kappa90, -m_r.y()),
m_c + vec2(m_r.x(), -m_r.y()*esvg::kappa90),
m_c + vec2(m_r.x(), 0.0f));
m_c + Vector2f(m_r.x()*esvg::kappa90, -m_r.y()),
m_c + Vector2f(m_r.x(), -m_r.y()*esvg::kappa90),
m_c + Vector2f(m_r.x(), 0.0f));
out.close();
return out;
}
@ -149,7 +149,7 @@ void esvg::Ellipse::draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32
}
void esvg::Ellipse::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void esvg::Ellipse::drawShapePoints(List<etk::Vector<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,
@ -162,7 +162,7 @@ void esvg::Ellipse::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
listPoints = listElement.generateListPoints(_level, _recurtionMax, _threshold);
listPoints.applyMatrix(mtx);
for (auto &it : listPoints.m_data) {
etk::Vector<vec2> listPoint;
List<Vector2f> listPoint;
for (auto &itDot : it) {
listPoint.pushBack(itDot.m_pos);
}

8
src/org/atriasoft/esvg/Ellipse.java
View File

@ -10,15 +10,15 @@
namespace esvg {
class Ellipse : public esvg::Base {
private:
vec2 m_c; //!< Center property of the ellipse
vec2 m_r; //!< Radius property of the ellipse
Vector2f m_c; //!< Center property of the ellipse
Vector2f m_r; //!< Radius property of the ellipse
public:
Ellipse(PaintState _parentPaintState);
~Ellipse();
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) override;
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) override;
void display(int32_t _spacing) override;
void draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t _level) override;
void drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void drawShapePoints(List<List<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

10
src/org/atriasoft/esvg/Group.cpp
View File

@ -26,13 +26,13 @@ esvg::Group::~Group() {
}
bool esvg::Group::parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::Group::parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
if (_element.exist() == false) {
return false;
}
// parse ...
vec2 pos(0,0);
vec2 size(0,0);
Vector2f pos(0,0);
Vector2f size(0,0);
parseTransform(_element);
parsePosition(_element, pos, size);
parsePaintAttr(_element);
@ -44,7 +44,7 @@ bool esvg::Group::parseXML(const exml::Element& _element, mat2x3& _parentTrans,
Log.verbose("parsed G2. trans : " << m_transformMatrix);
_sizeMax.setValue(0,0);
vec2 tmpPos(0,0);
Vector2f tmpPos(0,0);
// parse all sub node :
for(const auto it : _element.nodes) {
exml::Element child = it.toElement();
@ -114,7 +114,7 @@ void esvg::Group::draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t
}
}
void esvg::Group::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void esvg::Group::drawShapePoints(List<etk::Vector<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

6
src/org/atriasoft/esvg/Group.java
View File

@ -11,14 +11,14 @@
namespace esvg {
class Group : public esvg::Base {
private:
etk::Vector<ememory::SharedPtr<esvg::Base>> m_subElementList; //!< sub elements ...
List<ememory::SharedPtr<esvg::Base>> m_subElementList; //!< sub elements ...
public:
Group(PaintState _parentPaintState);
~Group();
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) override;
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) override;
void display(int32_t spacing) override;
void draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t _level) override;
void drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void drawShapePoints(List<List<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

6
src/org/atriasoft/esvg/Line.cpp
View File

@ -18,7 +18,7 @@ esvg::Line::~Line() {
}
bool esvg::Line::parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::Line::parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
// line must have a minimum size...
m_paint.strokeWidth = 1;
if (_element.exist() == false) {
@ -116,7 +116,7 @@ void esvg::Line::draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t
}
void esvg::Line::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void esvg::Line::drawShapePoints(List<etk::Vector<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,
@ -129,7 +129,7 @@ void esvg::Line::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
listPoints = listElement.generateListPoints(_level, _recurtionMax, _threshold);
listPoints.applyMatrix(mtx);
for (auto &it : listPoints.m_data) {
etk::Vector<vec2> listPoint;
List<Vector2f> listPoint;
for (auto &itDot : it) {
listPoint.pushBack(itDot.m_pos);
}

8
src/org/atriasoft/esvg/Line.java
View File

@ -10,15 +10,15 @@
namespace esvg {
class Line : public esvg::Base {
private:
vec2 m_startPos; //!< Start line position
vec2 m_stopPos; //!< Stop line position
Vector2f m_startPos; //!< Start line position
Vector2f m_stopPos; //!< Stop line position
public:
Line(PaintState _parentPaintState);
~Line();
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) override;
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) override;
void display(int32_t _spacing) override;
void draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t _level) override;
void drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void drawShapePoints(List<List<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

8
src/org/atriasoft/esvg/LinearGradient.cpp
View File

@ -13,8 +13,8 @@
esvg::LinearGradient::LinearGradient(PaintState _parentPaintState) :
esvg::Base(_parentPaintState),
m_pos1(vec2(50,50), esvg::distance_pourcent),
m_pos2(vec2(50,50), esvg::distance_pourcent),
m_pos1(Vector2f(50,50), esvg::distance_pourcent),
m_pos2(Vector2f(50,50), esvg::distance_pourcent),
m_unit(gradientUnits_objectBoundingBox),
m_spread(spreadMethod_pad) {
@ -25,7 +25,7 @@ esvg::LinearGradient::~LinearGradient() {
}
bool esvg::LinearGradient::parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::LinearGradient::parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
// line must have a minimum size...
//m_paint.strokeWidth = 1;
if (_element.exist() == false) {
@ -147,7 +147,7 @@ const esvg::Dimension& esvg::LinearGradient::getPosition2() {
return m_pos2;
}
const etk::Vector<etk::Pair<float, etk::Color<float,4>>>& esvg::LinearGradient::getColors(esvg::Document* _document) {
const List<etk::Pair<float, etk::Color<float,4>>>& esvg::LinearGradient::getColors(esvg::Document* _document) {
if (m_href == "") {
return m_data;
}

6
src/org/atriasoft/esvg/LinearGradient.java
View File

@ -20,17 +20,17 @@ namespace esvg {
enum spreadMethod m_spread;
private:
etk::String m_href; //!< in case of using a single gradient in multiple gradient, the gradient is store in an other element...
etk::Vector<etk::Pair<float, etk::Color<float,4>>> m_data; //!< incompatible with href
List<etk::Pair<float, etk::Color<float,4>>> m_data; //!< incompatible with href
public:
LinearGradient(PaintState _parentPaintState);
~LinearGradient();
virtual bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax);
virtual bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax);
virtual void display(int32_t _spacing);
virtual void draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t _level);
public:
const esvg::Dimension& getPosition1();
const esvg::Dimension& getPosition2();
const etk::Vector<etk::Pair<float, etk::Color<float,4>>>& getColors(esvg::Document* _document);
const List<etk::Pair<float, etk::Color<float,4>>>& getColors(esvg::Document* _document);
};
}

36
src/org/atriasoft/esvg/Path.cpp
View File

@ -19,7 +19,7 @@ esvg::Path::~Path() {
// return the next char position ... (after 'X' or NULL)
const char * extractCmd(const char* _input, char& _cmd, etk::Vector<float>& _outputList) {
const char * extractCmd(const char* _input, char& _cmd, List<float>& _outputList) {
if (*_input == '\0') {
return null;
}
@ -76,7 +76,7 @@ etk::String cleanBadSpaces(const etk::String& _input) {
return out;
}
bool esvg::Path::parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::Path::parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
if (_element.exist() == false) {
return false;
}
@ -95,7 +95,7 @@ bool esvg::Path::parseXML(const exml::Element& _element, mat2x3& _parentTrans, v
Log.verbose("Parse Path : \"" << elementXML1 << "\"");
char command;
etk::Vector<float> listDot;
List<float> listDot;
elementXML1 = cleanBadSpaces(elementXML1);
const char* elementXML = elementXML1.c_str();
@ -114,11 +114,11 @@ bool esvg::Path::parseXML(const exml::Element& _element, mat2x3& _parentTrans, v
}
if (listDot.size() >= 2) {
m_listElement.moveTo(relative,
vec2(listDot[0], listDot[1]));
Vector2f(listDot[0], listDot[1]));
}
for (size_t iii=2; iii<listDot.size(); iii+=2) {
m_listElement.lineTo(relative,
vec2(listDot[iii], listDot[iii+1]));
Vector2f(listDot[iii], listDot[iii+1]));
}
break;
case 'l': // Line to (relative)
@ -131,7 +131,7 @@ bool esvg::Path::parseXML(const exml::Element& _element, mat2x3& _parentTrans, v
}
for (size_t iii=0; iii<listDot.size(); iii+=2) {
m_listElement.lineTo(relative,
vec2(listDot[iii], listDot[iii+1]));
Vector2f(listDot[iii], listDot[iii+1]));
}
break;
@ -173,8 +173,8 @@ bool esvg::Path::parseXML(const exml::Element& _element, mat2x3& _parentTrans, v
}
for (size_t iii=0; iii<listDot.size(); iii+=4) {
m_listElement.bezierCurveTo(relative,
vec2(listDot[iii],listDot[iii+1]),
vec2(listDot[iii+2],listDot[iii+3]));
Vector2f(listDot[iii],listDot[iii+1]),
Vector2f(listDot[iii+2],listDot[iii+3]));
}
break;
@ -188,7 +188,7 @@ bool esvg::Path::parseXML(const exml::Element& _element, mat2x3& _parentTrans, v
}
for (size_t iii=0; iii<listDot.size(); iii+=2) {
m_listElement.bezierSmoothCurveTo(relative,
vec2(listDot[iii],listDot[iii+1]));
Vector2f(listDot[iii],listDot[iii+1]));
}
break;
@ -202,9 +202,9 @@ bool esvg::Path::parseXML(const exml::Element& _element, mat2x3& _parentTrans, v
}
for (size_t iii=0; iii<listDot.size(); iii+=6) {
m_listElement.curveTo(relative,
vec2(listDot[iii],listDot[iii+1]),
vec2(listDot[iii+2],listDot[iii+3]),
vec2(listDot[iii+4],listDot[iii+5]));
Vector2f(listDot[iii],listDot[iii+1]),
Vector2f(listDot[iii+2],listDot[iii+3]),
Vector2f(listDot[iii+4],listDot[iii+5]));
}
break;
@ -218,8 +218,8 @@ bool esvg::Path::parseXML(const exml::Element& _element, mat2x3& _parentTrans, v
}
for (size_t iii=0; iii<listDot.size(); iii+=4) {
m_listElement.smoothCurveTo(relative,
vec2(listDot[iii],listDot[iii+1]),
vec2(listDot[iii+2],listDot[iii+3]));
Vector2f(listDot[iii],listDot[iii+1]),
Vector2f(listDot[iii+2],listDot[iii+3]));
}
break;
@ -241,11 +241,11 @@ bool esvg::Path::parseXML(const exml::Element& _element, mat2x3& _parentTrans, v
sweepFlag = false;
}
m_listElement.ellipticTo(relative,
vec2(listDot[iii], listDot[iii+1]),
Vector2f(listDot[iii], listDot[iii+1]),
listDot[iii+2],
largeArcFlag,
sweepFlag,
vec2(listDot[iii+5], listDot[iii+6]) );
Vector2f(listDot[iii+5], listDot[iii+6]) );
}
break;
case 'z': // closepath (relative)
@ -325,7 +325,7 @@ void esvg::Path::draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t
}
void esvg::Path::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void esvg::Path::drawShapePoints(List<etk::Vector<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,
@ -339,7 +339,7 @@ void esvg::Path::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
listPoints = m_listElement.generateListPoints(_level, _recurtionMax, _threshold);
listPoints.applyMatrix(mtx);
for (auto &it : listPoints.m_data) {
etk::Vector<vec2> listPoint;
List<Vector2f> listPoint;
for (auto &itDot : it) {
listPoint.pushBack(itDot.m_pos);
}

4
src/org/atriasoft/esvg/Path.java
View File

@ -15,10 +15,10 @@ namespace esvg {
public:
Path(PaintState _parentPaintState);
~Path();
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) override;
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) override;
void display(int32_t _spacing) override;
void draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t _level) override;
void drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void drawShapePoints(List<List<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

8
src/org/atriasoft/esvg/Polygon.cpp
View File

@ -17,7 +17,7 @@ esvg::Polygon::~Polygon() {
}
bool esvg::Polygon::parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::Polygon::parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
if (_element.exist() == false) {
return false;
}
@ -40,7 +40,7 @@ bool esvg::Polygon::parseXML(const exml::Element& _element, mat2x3& _parentTrans
_sizeMax.setValue(0,0);
Log.verbose("Parse polygon : \"" << sss << "\"");
while ('\0' != sss[0]) {
vec2 pos(0,0);
Vector2f pos(0,0);
int32_t n;
if (sscanf(sss, "%f,%f%n", &pos.m_floats[0], &pos.m_floats[1], &n) == 2) {
m_listPoint.pushBack(pos);
@ -130,7 +130,7 @@ void esvg::Polygon::draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32
}
void esvg::Polygon::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void esvg::Polygon::drawShapePoints(List<etk::Vector<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,
@ -143,7 +143,7 @@ void esvg::Polygon::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
listPoints = listElement.generateListPoints(_level, _recurtionMax, _threshold);
listPoints.applyMatrix(mtx);
for (auto &it : listPoints.m_data) {
etk::Vector<vec2> listPoint;
List<Vector2f> listPoint;
for (auto &itDot : it) {
listPoint.pushBack(itDot.m_pos);
}

6
src/org/atriasoft/esvg/Polygon.java
View File

@ -17,15 +17,15 @@ namespace esvg {
*/
class Polygon : public esvg::Base {
private:
etk::Vector<vec2 > m_listPoint; //!< list of all point of the polygone
List<Vector2f > m_listPoint; //!< list of all point of the polygone
//enum esvg::polygonMode m_diplayMode; //!< polygone specific display mode
public:
Polygon(PaintState parentPaintState);
~Polygon();
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) override;
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) override;
void display(int32_t _spacing) override;
void draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t _level) override;
void drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void drawShapePoints(List<List<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

8
src/org/atriasoft/esvg/Polyline.cpp
View File

@ -17,7 +17,7 @@ esvg::Polyline::~Polyline() {
}
bool esvg::Polyline::parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::Polyline::parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
// line must have a minimum size...
m_paint.strokeWidth = 1;
if (_element.exist() == false) {
@ -38,7 +38,7 @@ bool esvg::Polyline::parseXML(const exml::Element& _element, mat2x3& _parentTran
Log.verbose("Parse polyline : \"" << sss1 << "\"");
const char* sss = sss1.c_str();
while ('\0' != sss[0]) {
vec2 pos;
Vector2f pos;
int32_t n;
if (sscanf(sss, "%f,%f %n", &pos.m_floats[0], &pos.m_floats[1], &n) == 2) {
m_listPoint.pushBack(pos);
@ -127,7 +127,7 @@ void esvg::Polyline::draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int3
}
void esvg::Polyline::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void esvg::Polyline::drawShapePoints(List<etk::Vector<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,
@ -140,7 +140,7 @@ void esvg::Polyline::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
listPoints = listElement.generateListPoints(_level, _recurtionMax, _threshold);
listPoints.applyMatrix(mtx);
for (auto &it : listPoints.m_data) {
etk::Vector<vec2> listPoint;
List<Vector2f> listPoint;
for (auto &itDot : it) {
listPoint.pushBack(itDot.m_pos);
}

6
src/org/atriasoft/esvg/Polyline.java
View File

@ -11,14 +11,14 @@
namespace esvg {
class Polyline : public esvg::Base {
private:
etk::Vector<vec2 > m_listPoint; //!< list of all point of the polyline
List<Vector2f > m_listPoint; //!< list of all point of the polyline
public:
Polyline(PaintState _parentPaintState);
~Polyline();
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) override;
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) override;
void display(int32_t _spacing) override;
void draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t _level) override;
void drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void drawShapePoints(List<List<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

8
src/org/atriasoft/esvg/RadialGradient.cpp
View File

@ -13,9 +13,9 @@
esvg::RadialGradient::RadialGradient(PaintState _parentPaintState) :
esvg::Base(_parentPaintState),
m_center(vec2(50,50), esvg::distance_pourcent),
m_center(Vector2f(50,50), esvg::distance_pourcent),
m_radius(50, esvg::distance_pourcent),
m_focal(vec2(50,50), esvg::distance_pourcent),
m_focal(Vector2f(50,50), esvg::distance_pourcent),
m_unit(gradientUnits_objectBoundingBox),
m_spread(spreadMethod_pad) {
@ -26,7 +26,7 @@ esvg::RadialGradient::~RadialGradient() {
}
bool esvg::RadialGradient::parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::RadialGradient::parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
// line must have a minimum size...
//m_paint.strokeWidth = 1;
if (_element.exist() == false) {
@ -156,7 +156,7 @@ const esvg::Dimension1D& esvg::RadialGradient::getRadius() {
return m_radius;
}
const etk::Vector<etk::Pair<float, etk::Color<float,4>>>& esvg::RadialGradient::getColors(esvg::Document* _document) {
const List<etk::Pair<float, etk::Color<float,4>>>& esvg::RadialGradient::getColors(esvg::Document* _document) {
if (m_href == "") {
return m_data;
}

6
src/org/atriasoft/esvg/RadialGradient.java
View File

@ -21,18 +21,18 @@ namespace esvg {
enum spreadMethod m_spread;
private:
etk::String m_href; //!< in case of using a single gradient in multiple gradient, the gradient is store in an other element...
etk::Vector<etk::Pair<float, etk::Color<float,4>>> m_data; //!< incompatible with href
List<etk::Pair<float, etk::Color<float,4>>> m_data; //!< incompatible with href
public:
RadialGradient(PaintState _parentPaintState);
~RadialGradient();
virtual bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax);
virtual bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax);
virtual void display(int32_t _spacing);
virtual void draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t _level);
public:
const esvg::Dimension& getCenter();
const esvg::Dimension& getFocal();
const esvg::Dimension1D& getRadius();
const etk::Vector<etk::Pair<float, etk::Color<float,4>>>& getColors(esvg::Document* _document);
const List<etk::Pair<float, etk::Color<float,4>>>& getColors(esvg::Document* _document);
};
}

32
src/org/atriasoft/esvg/Rectangle.cpp
View File

@ -19,7 +19,7 @@ esvg::Rectangle::~Rectangle() {
}
bool esvg::Rectangle::parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::Rectangle::parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
if (_element.exist() == false) {
return false;
}
@ -63,23 +63,23 @@ esvg::render::Path esvg::Rectangle::createPath() {
out.lineToH(true, -m_size.x());
} else {
// Rounded rectangle
out.moveTo(false, m_position + vec2(m_roundedCorner.x(), 0.0f));
out.moveTo(false, m_position + Vector2f(m_roundedCorner.x(), 0.0f));
out.lineToH(true, m_size.x()-m_roundedCorner.x()*2.0f);
out.curveTo(true, vec2(m_roundedCorner.x()*esvg::kappa90, 0.0f),
vec2(m_roundedCorner.x(), m_roundedCorner.y() * (1.0f - esvg::kappa90)),
vec2(m_roundedCorner.x(), m_roundedCorner.y()) );
out.curveTo(true, Vector2f(m_roundedCorner.x()*esvg::kappa90, 0.0f),
Vector2f(m_roundedCorner.x(), m_roundedCorner.y() * (1.0f - esvg::kappa90)),
Vector2f(m_roundedCorner.x(), m_roundedCorner.y()) );
out.lineToV(true, m_size.y()-m_roundedCorner.y()*2.0f);
out.curveTo(true, vec2(0.0f, m_roundedCorner.y() * esvg::kappa90),
vec2(-m_roundedCorner.x()* (1.0f - esvg::kappa90), m_roundedCorner.y()),
vec2(-m_roundedCorner.x(), m_roundedCorner.y()) );
out.curveTo(true, Vector2f(0.0f, m_roundedCorner.y() * esvg::kappa90),
Vector2f(-m_roundedCorner.x()* (1.0f - esvg::kappa90), m_roundedCorner.y()),
Vector2f(-m_roundedCorner.x(), m_roundedCorner.y()) );
out.lineToH(true, -(m_size.x()-m_roundedCorner.x()*2.0f));
out.curveTo(true, vec2(-m_roundedCorner.x()*esvg::kappa90, 0.0f),
vec2(-m_roundedCorner.x(), -m_roundedCorner.y() * (1.0f - esvg::kappa90)),
vec2(-m_roundedCorner.x(), -m_roundedCorner.y()) );
out.curveTo(true, Vector2f(-m_roundedCorner.x()*esvg::kappa90, 0.0f),
Vector2f(-m_roundedCorner.x(), -m_roundedCorner.y() * (1.0f - esvg::kappa90)),
Vector2f(-m_roundedCorner.x(), -m_roundedCorner.y()) );
out.lineToV(true, -(m_size.y()-m_roundedCorner.y()*2.0f));
out.curveTo(true, vec2(0.0f, -m_roundedCorner.y() * esvg::kappa90),
vec2(m_roundedCorner.x()* (1.0f - esvg::kappa90), -m_roundedCorner.y()),
vec2(m_roundedCorner.x(), -m_roundedCorner.y()) );
out.curveTo(true, Vector2f(0.0f, -m_roundedCorner.y() * esvg::kappa90),
Vector2f(m_roundedCorner.x()* (1.0f - esvg::kappa90), -m_roundedCorner.y()),
Vector2f(m_roundedCorner.x(), -m_roundedCorner.y()) );
}
out.close();
return out;
@ -144,7 +144,7 @@ void esvg::Rectangle::draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int
}
void esvg::Rectangle::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void esvg::Rectangle::drawShapePoints(List<etk::Vector<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,
@ -157,7 +157,7 @@ void esvg::Rectangle::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
listPoints = listElement.generateListPoints(_level, _recurtionMax, _threshold);
listPoints.applyMatrix(mtx);
for (auto &it : listPoints.m_data) {
etk::Vector<vec2> listPoint;
List<Vector2f> listPoint;
for (auto &itDot : it) {
listPoint.pushBack(itDot.m_pos);
}

10
src/org/atriasoft/esvg/Rectangle.java
View File

@ -10,16 +10,16 @@
namespace esvg {
class Rectangle : public esvg::Base {
private:
vec2 m_position; //!< position of the rectangle
vec2 m_size; //!< size of the rectangle
vec2 m_roundedCorner; //!< property of the rounded corner
Vector2f m_position; //!< position of the rectangle
Vector2f m_size; //!< size of the rectangle
Vector2f m_roundedCorner; //!< property of the rounded corner
public:
Rectangle(PaintState _parentPaintState);
~Rectangle();
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) override;
bool parseXML(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) override;
void display(int32_t _spacing) override;
void draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t _level) override;
void drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void drawShapePoints(List<List<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

50
src/org/atriasoft/esvg/Renderer.cpp
View File

@ -9,7 +9,7 @@
#include <etk/uri/Uri.hpp>
#include <etk/uri/provider/provider.hpp>
esvg::Renderer::Renderer(const ivec2& _size, esvg::Document* _document, bool _visualDebug) :
esvg::Renderer::Renderer(const Vector2i& _size, esvg::Document* _document, bool _visualDebug) :
#ifdef DEBUG
m_visualDebug(_visualDebug),
m_factor(1),
@ -28,7 +28,7 @@ esvg::Renderer::Renderer(const ivec2& _size, esvg::Document* _document, bool _vi
esvg::Renderer::~Renderer() {
m_buffer.clear();
m_size = ivec2(0,0);
m_size = Vector2i(0,0);
}
etk::Color<float,4> esvg::Renderer::mergeColor(etk::Color<float,4> _base, etk::Color<float,4> _integration) {
@ -59,17 +59,17 @@ void esvg::Renderer::print(const esvg::render::Weight& _weightFill,
ememory::SharedPtr<esvg::render::DynamicColor>& _colorStroke,
float _opacity) {
if (_colorFill != null) {
//_colorFill->setViewPort(etk::Pair<vec2, vec2>(vec2(0,0), vec2(sizeX, sizeY)));
//_colorFill->setViewPort(etk::Pair<Vector2f, Vector2f>(Vector2f(0,0), Vector2f(sizeX, sizeY)));
_colorFill->generate(m_document);
}
if (_colorStroke != null) {
//_colorStroke->setViewPort(etk::Pair<vec2, vec2>(vec2(0,0), vec2(sizeX, sizeY)));
//_colorStroke->setViewPort(etk::Pair<Vector2f, Vector2f>(Vector2f(0,0), Vector2f(sizeX, sizeY)));
_colorStroke->generate(m_document);
}
// all together
for (int32_t yyy=0; yyy<m_size.y(); ++yyy) {
for (int32_t xxx=0; xxx<m_size.x(); ++xxx) {
ivec2 pos(xxx, yyy);
Vector2i pos(xxx, yyy);
float valueFill = _weightFill.get(pos);
float valueStroke = _weightStroke.get(pos);
// calculate merge of stroke and fill value:
@ -106,15 +106,15 @@ void esvg::Renderer::print(const esvg::render::Weight& _weightFill,
esvg::render::SegmentList listSegment;
// Display bounding box
listSegment.addSegment(esvg::render::Point(tmpColor->m_viewPort.first),
esvg::render::Point(vec2(tmpColor->m_viewPort.first.x(), tmpColor->m_viewPort.second.y()) ),
esvg::render::Point(Vector2f(tmpColor->m_viewPort.first.x(), tmpColor->m_viewPort.second.y()) ),
false);
listSegment.addSegment(esvg::render::Point(vec2(tmpColor->m_viewPort.first.x(), tmpColor->m_viewPort.second.y()) ),
listSegment.addSegment(esvg::render::Point(Vector2f(tmpColor->m_viewPort.first.x(), tmpColor->m_viewPort.second.y()) ),
esvg::render::Point(tmpColor->m_viewPort.second),
false);
listSegment.addSegment(esvg::render::Point(tmpColor->m_viewPort.second),
esvg::render::Point(vec2(tmpColor->m_viewPort.second.x(), tmpColor->m_viewPort.first.y()) ),
esvg::render::Point(Vector2f(tmpColor->m_viewPort.second.x(), tmpColor->m_viewPort.first.y()) ),
false);
listSegment.addSegment(esvg::render::Point(vec2(tmpColor->m_viewPort.second.x(), tmpColor->m_viewPort.first.y()) ),
listSegment.addSegment(esvg::render::Point(Vector2f(tmpColor->m_viewPort.second.x(), tmpColor->m_viewPort.first.y()) ),
esvg::render::Point(tmpColor->m_viewPort.first),
false);
listSegment.applyMatrix(tmpColor->m_matrix);
@ -124,9 +124,9 @@ void esvg::Renderer::print(const esvg::render::Weight& _weightFill,
false);
/*
mat2x3 m_matrix;
etk::Pair<vec2, vec2> m_viewPort;
vec2 m_pos1;
vec2 m_pos2;
etk::Pair<Vector2f, Vector2f> m_viewPort;
Vector2f m_pos1;
Vector2f m_pos2;
*/
addDebugSegment(listSegment);
}
@ -138,11 +138,11 @@ void esvg::Renderer::print(const esvg::render::Weight& _weightFill,
if (m_visualDebug == false) {
return;
}
ivec2 dynamicSize = m_size * m_factor;
Vector2i dynamicSize = m_size * m_factor;
// for each lines:
for (int32_t yyy=0; yyy<dynamicSize.y(); ++yyy) {
// Reduce the number of lines in the subsampling parsing:
etk::Vector<esvg::render::Segment> availlableSegmentPixel;
List<esvg::render::Segment> availlableSegmentPixel;
for (auto &it : _listSegment.m_data) {
if ( it.p0.y() * m_factor <= float(yyy+1)
&& it.p1.y() * m_factor >= float(yyy)) {
@ -151,7 +151,7 @@ void esvg::Renderer::print(const esvg::render::Weight& _weightFill,
}
//find all the segment that cross the middle of the line of the center of the pixel line:
float subSamplingCenterPos = yyy + 0.5f;
etk::Vector<esvg::render::Segment> availlableSegment;
List<esvg::render::Segment> availlableSegment;
// find in the subList ...
for (auto &it : availlableSegmentPixel) {
if ( it.p0.y() * m_factor <= subSamplingCenterPos
@ -160,9 +160,9 @@ void esvg::Renderer::print(const esvg::render::Weight& _weightFill,
}
}
// x position, angle
etk::Vector<etk::Pair<float, float>> listPosition;
List<etk::Pair<float, float>> listPosition;
for (auto &it : availlableSegment) {
vec2 delta = it.p0 * m_factor - it.p1 * m_factor;
Vector2f delta = it.p0 * m_factor - it.p1 * m_factor;
// x = coefficent*y+bbb;
float coefficient = delta.x()/delta.y();
float bbb = it.p0.x() * m_factor - coefficient*it.p0.y() * m_factor;
@ -182,7 +182,7 @@ void esvg::Renderer::print(const esvg::render::Weight& _weightFill,
// for each colomn:
for (int32_t xxx=0; xxx<dynamicSize.x(); ++xxx) {
// Reduce the number of lines in the subsampling parsing:
etk::Vector<esvg::render::Segment> availlableSegmentPixel;
List<esvg::render::Segment> availlableSegmentPixel;
for (auto &it : _listSegment.m_data) {
if ( ( it.p0.x() * m_factor <= float(xxx+1)
&& it.p1.x() * m_factor >= float(xxx) )
@ -193,7 +193,7 @@ void esvg::Renderer::print(const esvg::render::Weight& _weightFill,
}
//find all the segment that cross the middle of the line of the center of the pixel line:
float subSamplingCenterPos = xxx + 0.5f;
etk::Vector<esvg::render::Segment> availlableSegment;
List<esvg::render::Segment> availlableSegment;
// find in the subList ...
for (auto &it : availlableSegmentPixel) {
if ( ( it.p0.x() * m_factor <= subSamplingCenterPos
@ -204,9 +204,9 @@ void esvg::Renderer::print(const esvg::render::Weight& _weightFill,
}
}
// x position, angle
etk::Vector<etk::Pair<float, float>> listPosition;
List<etk::Pair<float, float>> listPosition;
for (auto &it : availlableSegment) {
vec2 delta = it.p0 * m_factor - it.p1 * m_factor;
Vector2f delta = it.p0 * m_factor - it.p1 * m_factor;
// x = coefficent*y+bbb;
if (delta.x() == 0) {
continue;
@ -249,7 +249,7 @@ void esvg::Renderer::writePPM(const etk::Uri& _uri) {
sizeX *= m_factor;
sizeY *= m_factor;
#endif
Log.debug("Generate ppm : " << m_size << " debug size=" << ivec2(sizeX,sizeY));
Log.debug("Generate ppm : " << m_size << " debug size=" << Vector2i(sizeX,sizeY));
char tmpValue[1024];
sprintf(tmpValue, "P6 %d %d 255 ", sizeX, sizeY);
fileIo->write(tmpValue,1,sizeof(tmpValue));
@ -380,7 +380,7 @@ void esvg::Renderer::writeBMP(const etk::Uri& _uri) {
}
void esvg::Renderer::setSize(const ivec2& _size) {
void esvg::Renderer::setSize(const Vector2i& _size) {
m_size = _size;
m_buffer.resize(m_size.x() * m_size.y()
#if DEBUG
@ -389,11 +389,11 @@ void esvg::Renderer::setSize(const ivec2& _size) {
, etk::color::none);
}
const ivec2& esvg::Renderer::getSize() const {
const Vector2i& esvg::Renderer::getSize() const {
return m_size;
}
etk::Vector<etk::Color<float,4>> esvg::Renderer::getData() {
List<etk::Color<float,4>> esvg::Renderer::getData() {
return m_buffer;
}

14
src/org/atriasoft/esvg/Renderer.java
View File

@ -21,17 +21,17 @@ namespace esvg {
int32_t m_factor;
#endif
public:
Renderer(const ivec2& _size, esvg::Document* _document, bool _visualDebug=false);
Renderer(const Vector2i& _size, esvg::Document* _document, bool _visualDebug=false);
~Renderer();
protected:
ivec2 m_size;
Vector2i m_size;
public:
void setSize(const ivec2& _size);
const ivec2& getSize() const;
void setSize(const Vector2i& _size);
const Vector2i& getSize() const;
protected:
etk::Vector<etk::Color<float,4>> m_buffer;
List<etk::Color<float,4>> m_buffer;
public:
etk::Vector<etk::Color<float,4>> getData();
List<etk::Color<float,4>> getData();
protected:
int32_t m_interpolationRecurtionMax;
public:
@ -60,7 +60,7 @@ namespace esvg {
float _opacity);
#ifdef DEBUG
void addDebugSegment(const esvg::render::SegmentList& _listSegment);
void addDebug(const etk::Vector<etk::Pair<vec2,vec2>>& _info);
void addDebug(const List<etk::Pair<Vector2f,Vector2f>>& _info);
#endif
protected:
esvg::Document* m_document;

2
src/org/atriasoft/esvg/Text.cpp
View File

@ -15,7 +15,7 @@ esvg::Text::~Text() {
}
bool esvg::Text::parse(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax) {
bool esvg::Text::parse(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax) {
_sizeMax.setValue(0,0);
Log.error("NOT IMPLEMENTED");
return false;

2
src/org/atriasoft/esvg/Text.java
View File

@ -12,7 +12,7 @@ namespace esvg {
public:
Text(PaintState _parentPaintState);
~Text();
bool parse(const exml::Element& _element, mat2x3& _parentTrans, vec2& _sizeMax);
bool parse(const exml::Element& _element, mat2x3& _parentTrans, Vector2f& _sizeMax);
void display(int32_t _spacing) override;
};
}

48
src/org/atriasoft/esvg/esvg.cpp
View File

@ -61,8 +61,8 @@ void esvg::Document::draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int3
void esvg::Document::generateAnImage(const etk::Uri& _uri, bool _visualDebug) {
generateAnImage(m_size, _uri, _visualDebug);
}
void esvg::Document::generateAnImage(const ivec2& _size, const etk::Uri& _uri, bool _visualDebug) {
ivec2 sizeRender = _size;
void esvg::Document::generateAnImage(const Vector2i& _size, const etk::Uri& _uri, bool _visualDebug) {
Vector2i sizeRender = _size;
if (sizeRender.x() <= 0) {
sizeRender.setX(m_size.x());
}
@ -74,7 +74,7 @@ void esvg::Document::generateAnImage(const ivec2& _size, const etk::Uri& _uri, b
ememory::SharedPtr<esvg::Renderer> renderedElement = ememory::makeShared<esvg::Renderer>(sizeRender, this, _visualDebug);
// create the first element matrix modification ...
mat2x3 basicTrans;
basicTrans *= etk::mat2x3Scale(vec2(sizeRender.x()/m_size.x(), sizeRender.y()/m_size.y()));
basicTrans *= etk::mat2x3Scale(Vector2f(sizeRender.x()/m_size.x(), sizeRender.y()/m_size.y()));
draw(*renderedElement, basicTrans);
@ -88,7 +88,7 @@ void esvg::Document::generateAnImage(const ivec2& _size, const etk::Uri& _uri, b
}
etk::Vector<etk::Color<float,4>> esvg::Document::renderImageFloatRGBA(ivec2& _size) {
List<etk::Color<float,4>> esvg::Document::renderImageFloatRGBA(Vector2i& _size) {
if (_size.x() <= 0) {
_size.setX(m_size.x());
}
@ -99,17 +99,17 @@ etk::Vector<etk::Color<float,4>> esvg::Document::renderImageFloatRGBA(ivec2& _si
ememory::SharedPtr<esvg::Renderer> renderedElement = ememory::makeShared<esvg::Renderer>(_size, this);
// create the first element matrix modification ...
mat2x3 basicTrans;
basicTrans *= etk::mat2x3Scale(vec2(_size.x()/m_size.x(), _size.y()/m_size.y()));
basicTrans *= etk::mat2x3Scale(Vector2f(_size.x()/m_size.x(), _size.y()/m_size.y()));
draw(*renderedElement, basicTrans);
// direct return the generated data ...
return renderedElement->getData();
}
etk::Vector<etk::Color<float,3>> esvg::Document::renderImageFloatRGB(ivec2& _size) {
etk::Vector<etk::Color<float,4>> data = renderImageFloatRGBA(_size);
List<etk::Color<float,3>> esvg::Document::renderImageFloatRGB(Vector2i& _size) {
List<etk::Color<float,4>> data = renderImageFloatRGBA(_size);
// Reduce scope:
etk::Vector<etk::Color<float,3>> out;
List<etk::Color<float,3>> out;
out.resize(data.size());
for (size_t iii=0; iii<data.size(); ++iii) {
out[iii] = data[iii];
@ -117,10 +117,10 @@ etk::Vector<etk::Color<float,3>> esvg::Document::renderImageFloatRGB(ivec2& _siz
return out;
}
etk::Vector<etk::Color<uint8_t,4>> esvg::Document::renderImageU8RGBA(ivec2& _size) {
etk::Vector<etk::Color<float,4>> data = renderImageFloatRGBA(_size);
List<etk::Color<uint8_t,4>> esvg::Document::renderImageU8RGBA(Vector2i& _size) {
List<etk::Color<float,4>> data = renderImageFloatRGBA(_size);
// Reduce scope:
etk::Vector<etk::Color<uint8_t,4>> out;
List<etk::Color<uint8_t,4>> out;
out.resize(data.size());
for (size_t iii=0; iii<data.size(); ++iii) {
out[iii] = data[iii];
@ -128,10 +128,10 @@ etk::Vector<etk::Color<uint8_t,4>> esvg::Document::renderImageU8RGBA(ivec2& _siz
return out;
}
etk::Vector<etk::Color<uint8_t,3>> esvg::Document::renderImageU8RGB(ivec2& _size) {
etk::Vector<etk::Color<float,4>> data = renderImageFloatRGBA(_size);
List<etk::Color<uint8_t,3>> esvg::Document::renderImageU8RGB(Vector2i& _size) {
List<etk::Color<float,4>> data = renderImageFloatRGBA(_size);
// Reduce scope:
etk::Vector<etk::Color<uint8_t,3>> out;
List<etk::Color<uint8_t,3>> out;
out.resize(data.size());
for (size_t iii=0; iii<data.size(); ++iii) {
out[iii] = data[iii];
@ -202,7 +202,7 @@ bool esvg::Document::load(const etk::Uri& _uri) {
}
bool esvg::Document::store(const etk::Uri& _uri) {
ESVG_TODO("not implemented store in SVG...");
Log.todo("not implemented store in SVG...");
return false;
}
@ -217,9 +217,9 @@ bool esvg::Document::cleanStyleProperty(const exml::Element& _root) {
if (child.attributes.exist("style") == true) {
etk::String content = child.attributes["style"];
if (content.size() != 0) {
etk::Vector<etk::String> listStyle = etk::split(content, ';');
List<etk::String> listStyle = etk::split(content, ';');
for (auto &it : listStyle) {
etk::Vector<etk::String> value = etk::split(it, ':');
List<etk::String> value = etk::split(it, ':');
if (value.size() != 2) {
Log.error("parsing style with a wrong patern : " << it << " missing ':'");
continue;
@ -241,7 +241,7 @@ bool esvg::Document::parseXMLData(const exml::Element& _root, bool _isReference)
// get the svg version :
m_version = _root.attributes["version"];
// parse ...
vec2 pos(0,0);
Vector2f pos(0,0);
if (_isReference == false) {
parseTransform(_root);
parsePosition(_root, pos, m_size);
@ -250,8 +250,8 @@ bool esvg::Document::parseXMLData(const exml::Element& _root, bool _isReference)
} else {
Log.verbose("Parse Reference section ... (no attibute)");
}
vec2 maxSize(0,0);
vec2 size(0,0);
Vector2f maxSize(0,0);
Vector2f size(0,0);
// parse all sub node:
for(auto it : _root.nodes) {
exml::Element child = it.toElement();
@ -369,8 +369,8 @@ ememory::SharedPtr<esvg::Base> esvg::Document::getReference(const etk::String& _
return null;
}
etk::Vector<etk::Vector<vec2>> esvg::Document::getLines(vec2 _size) {
etk::Vector<etk::Vector<vec2>> out;
List<etk::Vector<Vector2f>> esvg::Document::getLines(Vector2f _size) {
List<etk::Vector<Vector2f>> out;
if (_size.x() <= 0) {
_size.setX(m_size.x());
}
@ -380,13 +380,13 @@ etk::Vector<etk::Vector<vec2>> esvg::Document::getLines(vec2 _size) {
Log.debug("lineification size " << _size);
// create the first element matrix modification ...
mat2x3 basicTrans;
basicTrans *= etk::mat2x3Scale(vec2(_size.x()/m_size.x(), _size.y()/m_size.y()));
basicTrans *= etk::mat2x3Scale(Vector2f(_size.x()/m_size.x(), _size.y()/m_size.y()));
drawShapePoints(out, 10, 0.25f, basicTrans);
return out;
}
void esvg::Document::drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void esvg::Document::drawShapePoints(List<etk::Vector<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

22
src/org/atriasoft/esvg/esvg.java
View File

@ -22,9 +22,9 @@ namespace esvg {
bool m_loadOK;
etk::String m_version;
etk::String m_title;
etk::Vector<ememory::SharedPtr<esvg::Base>> m_subElementList; //!< sub-element list
etk::Vector<ememory::SharedPtr<esvg::Base>> m_refList; //!< reference elements ...
vec2 m_size;
List<ememory::SharedPtr<esvg::Base>> m_subElementList; //!< sub-element list
List<ememory::SharedPtr<esvg::Base>> m_refList; //!< reference elements ...
Vector2f m_size;
public:
Document();
~Document();
@ -73,29 +73,29 @@ namespace esvg {
void displayDebug();
// TODO: remove this fucntion : use generic function ...
void generateAnImage(const etk::Uri& _uri, bool _visualDebug=false);
void generateAnImage(const ivec2& _size, const etk::Uri& _uri, bool _visualDebug=false);
void generateAnImage(const Vector2i& _size, const etk::Uri& _uri, bool _visualDebug=false);
/**
* @brief Generate Image in a specific format.
* @param[in,out] _size Size expected of the rendered image (value <=0 if it need to be automatic.) return the size generate
* @return Vector of the data used to display (simple vector: generic to transmit)
*/
etk::Vector<etk::Color<float,4>> renderImageFloatRGBA(ivec2& _size);
List<etk::Color<float,4>> renderImageFloatRGBA(Vector2i& _size);
//! @previous
etk::Vector<etk::Color<float,3>> renderImageFloatRGB(ivec2& _size);
List<etk::Color<float,3>> renderImageFloatRGB(Vector2i& _size);
//! @previous
etk::Vector<etk::Color<uint8_t,4>> renderImageU8RGBA(ivec2& _size);
List<etk::Color<uint8_t,4>> renderImageU8RGBA(Vector2i& _size);
//! @previous
etk::Vector<etk::Color<uint8_t,3>> renderImageU8RGB(ivec2& _size);
etk::Vector<etk::Vector<vec2>> getLines(vec2 _size=vec2(256,256));
List<etk::Color<uint8_t,3>> renderImageU8RGB(Vector2i& _size);
List<List<Vector2f>> getLines(Vector2f _size=Vector2f(256,256));
protected:
void draw(esvg::Renderer& _myRenderer, mat2x3& _basicTrans, int32_t _level=0) override;
public:
vec2 getDefinedSize() {
Vector2f getDefinedSize() {
return m_size;
};
ememory::SharedPtr<esvg::Base> getReference(const etk::String& _name);
protected:
void drawShapePoints(etk::Vector<etk::Vector<vec2>>& _out,
void drawShapePoints(List<List<Vector2f>>& _out,
int32_t _recurtionMax,
float _threshold,
mat2x3& _basicTrans,

126
src/org/atriasoft/esvg/render/DynamicColor.cpp
View File

@ -14,19 +14,19 @@ esvg::render::DynamicColorSpecial::DynamicColorSpecial(const etk::String& _link,
m_linear(true),
m_colorName(_link),
m_matrix(_mtx),
m_viewPort(vec2(9999999999.0,9999999999.0),vec2(-9999999999.0,-9999999999.0)) {
m_viewPort(Vector2f(9999999999.0,9999999999.0),Vector2f(-9999999999.0,-9999999999.0)) {
}
void esvg::render::DynamicColorSpecial::setViewPort(const etk::Pair<vec2, vec2>& _viewPort) {
void esvg::render::DynamicColorSpecial::setViewPort(const etk::Pair<Vector2f, Vector2f>& _viewPort) {
m_viewPort = _viewPort;
}
static vec2 getIntersect(const vec2& _point1,
const vec2& _vect1,
const vec2& _point2,
const vec2& _vect2) {
static Vector2f getIntersect(const Vector2f& _point1,
const Vector2f& _vect1,
const Vector2f& _point2,
const Vector2f& _vect2) {
float diviseur = _vect1.x() * _vect2.y() - _vect1.y() * _vect2.x();
if(diviseur != 0.0f) {
float mmm = ( _vect1.x() * _point1.y()
@ -34,13 +34,13 @@ static vec2 getIntersect(const vec2& _point1,
- _vect1.y() * _point1.x()
+ _vect1.y() * _point2.x()
) / diviseur;
return vec2(_point2 + _vect2 * mmm);
return Vector2f(_point2 + _vect2 * mmm);
}
Log.error("Get divider / 0.0f");
return _point2;
}
etk::Color<float,4> esvg::render::DynamicColorSpecial::getColor(const ivec2& _pos) const {
etk::Color<float,4> esvg::render::DynamicColorSpecial::getColor(const Vector2i& _pos) const {
if (m_data.size() < 2) {
return etk::color::purple;
}
@ -52,15 +52,15 @@ etk::Color<float,4> esvg::render::DynamicColorSpecial::getColor(const ivec2& _po
return etk::color::purple;
}
etk::Color<float,4> esvg::render::DynamicColorSpecial::getColorLinear(const ivec2& _pos) const {
etk::Color<float,4> esvg::render::DynamicColorSpecial::getColorLinear(const Vector2i& _pos) const {
float ratio = 0.0f;
if (m_unit == gradientUnits_userSpaceOnUse) {
vec2 vectorBase = m_pos2 - m_pos1;
vec2 vectorOrtho(vectorBase.y(), -vectorBase.x());
vec2 intersec = getIntersect(m_pos1, vectorBase,
vec2(_pos.x(), _pos.y()), vectorOrtho);
Vector2f vectorBase = m_pos2 - m_pos1;
Vector2f vectorOrtho(vectorBase.y(), -vectorBase.x());
Vector2f intersec = getIntersect(m_pos1, vectorBase,
Vector2f(_pos.x(), _pos.y()), vectorOrtho);
float baseSize = vectorBase.length();
vec2 vectorBaseDraw = intersec - m_pos1;
Vector2f vectorBaseDraw = intersec - m_pos1;
float baseDraw = vectorBaseDraw.length();
ratio = baseDraw / baseSize;
switch(m_spread) {
@ -91,12 +91,12 @@ etk::Color<float,4> esvg::render::DynamicColorSpecial::getColorLinear(const ivec
}
} else {
// in the basic vertion of the gradient the color is calculated with the ration in X and Y in the bonding box associated (it is rotate with the object..
vec2 intersecX = getIntersect(m_pos1, m_axeX,
vec2(_pos.x(), _pos.y()), m_axeY);
vec2 intersecY = getIntersect(m_pos1, m_axeY,
vec2(_pos.x(), _pos.y()), m_axeX);
vec2 vectorBaseDrawX = intersecX - m_pos1;
vec2 vectorBaseDrawY = intersecY - m_pos1;
Vector2f intersecX = getIntersect(m_pos1, m_axeX,
Vector2f(_pos.x(), _pos.y()), m_axeY);
Vector2f intersecY = getIntersect(m_pos1, m_axeY,
Vector2f(_pos.x(), _pos.y()), m_axeX);
Vector2f vectorBaseDrawX = intersecX - m_pos1;
Vector2f vectorBaseDrawY = intersecY - m_pos1;
float baseDrawX = vectorBaseDrawX.length();
float baseDrawY = vectorBaseDrawY.length();
if (m_axeX.dot(vectorBaseDrawX) < 0) {
@ -162,28 +162,28 @@ etk::Color<float,4> esvg::render::DynamicColorSpecial::getColorLinear(const ivec
}
return etk::color::green;
}
static etk::Pair<vec2,vec2> intersectLineToCircle(const vec2& _pos1,
const vec2& _pos2,
const vec2& _center = vec2(0.0f, 0.0f),
static etk::Pair<Vector2f,Vector2f> intersectLineToCircle(const Vector2f& _pos1,
const Vector2f& _pos2,
const Vector2f& _center = Vector2f(0.0f, 0.0f),
float _radius = 1.0f) {
vec2 v1;
vec2 v2;
Vector2f v1;
Vector2f v2;
//vector2D from point 1 to point 2
v1 = _pos2 - _pos1;
//vector2D from point 1 to the circle's center
v2 = _center - _pos1;
float dot = v1.dot(v2);
vec2 proj1 = vec2(((dot / (v1.length2())) * v1.x()),
Vector2f proj1 = Vector2f(((dot / (v1.length2())) * v1.x()),
((dot / (v1.length2())) * v1.y()));
vec2 midpt = _pos1 + proj1;
Vector2f midpt = _pos1 + proj1;
float distToCenter = (midpt - _center).length2();
if (distToCenter > _radius * _radius) {
return etk::Pair<vec2,vec2>(vec2(0.0,0.0), vec2(0.0,0.0));
return etk::Pair<Vector2f,Vector2f>(Vector2f(0.0,0.0), Vector2f(0.0,0.0));
}
if (distToCenter == _radius * _radius) {
return etk::Pair<vec2,vec2>(midpt, midpt);
return etk::Pair<Vector2f,Vector2f>(midpt, midpt);
}
float distToIntersection;
if (distToCenter == 0.0f) {
@ -200,27 +200,27 @@ static etk::Pair<vec2,vec2> intersectLineToCircle(const vec2& _pos1,
// normalize...
v1.safeNormalize();
v1 *= distToIntersection;
return etk::Pair<vec2,vec2>(midpt + v1, midpt - v1);
return etk::Pair<Vector2f,Vector2f>(midpt + v1, midpt - v1);
}
etk::Color<float,4> esvg::render::DynamicColorSpecial::getColorRadial(const ivec2& _pos) const {
etk::Color<float,4> esvg::render::DynamicColorSpecial::getColorRadial(const Vector2i& _pos) const {
float ratio = 0.0f;
// in the basic vertion of the gradient the color is calculated with the ration in X and Y in the bonding box associated (it is rotate with the object)..
vec2 intersecX = getIntersect(m_pos1, m_axeX,
vec2(_pos.x(), _pos.y()), m_axeY);
vec2 intersecY = getIntersect(m_pos1, m_axeY,
vec2(_pos.x(), _pos.y()), m_axeX);
vec2 vectorBaseDrawX = intersecX - m_pos1;
vec2 vectorBaseDrawY = intersecY - m_pos1;
Vector2f intersecX = getIntersect(m_pos1, m_axeX,
Vector2f(_pos.x(), _pos.y()), m_axeY);
Vector2f intersecY = getIntersect(m_pos1, m_axeY,
Vector2f(_pos.x(), _pos.y()), m_axeX);
Vector2f vectorBaseDrawX = intersecX - m_pos1;
Vector2f vectorBaseDrawY = intersecY - m_pos1;
float baseDrawX = vectorBaseDrawX.length();
float baseDrawY = vectorBaseDrawY.length();
// specal case when focal == center (this is faster ...)
if (m_centerIsFocal == true) {
ratio = vec2(baseDrawX, baseDrawY).length();
ratio = Vector2f(baseDrawX, baseDrawY).length();
if (m_baseSize.x()+m_baseSize.y() != 0.0f) {
if ( m_baseSize.x() != 0.0f
&& m_baseSize.y() != 0.0f) {
ratio = vec2(baseDrawX/m_baseSize.x(), baseDrawY/m_baseSize.y()).length();
ratio = Vector2f(baseDrawX/m_baseSize.x(), baseDrawY/m_baseSize.y()).length();
} else if (m_baseSize.x() != 0.0f) {
ratio = baseDrawX/m_baseSize.x();
} else {
@ -247,12 +247,12 @@ etk::Color<float,4> esvg::render::DynamicColorSpecial::getColorRadial(const ivec
ratio = 1.0f;
} else {
float tmpLength = -m_focalLength/m_baseSize.x();
vec2 focalCenter = vec2(tmpLength, 0.0f);
vec2 currentPoint = vec2(baseDrawX, baseDrawY);
Vector2f focalCenter = Vector2f(tmpLength, 0.0f);
Vector2f currentPoint = Vector2f(baseDrawX, baseDrawY);
if (focalCenter == currentPoint) {
ratio = 0.0f;
} else {
etk::Pair<vec2,vec2> positions = intersectLineToCircle(focalCenter, currentPoint);
etk::Pair<Vector2f,Vector2f> positions = intersectLineToCircle(focalCenter, currentPoint);
float lenghtBase = (currentPoint - focalCenter).length();
float lenghtBorder1 = (positions.first - focalCenter).length();
float lenghtBorder2 = (positions.second - focalCenter).length();
@ -320,7 +320,7 @@ void esvg::render::DynamicColorSpecial::generate(esvg::Document* _document) {
m_unit = gradient->m_unit;
m_spread = gradient->m_spread;
Log.verbose(" viewport = {" << m_viewPort.first << "," << m_viewPort.second << "}");
vec2 size = m_viewPort.second - m_viewPort.first;
Vector2f size = m_viewPort.second - m_viewPort.first;
esvg::Dimension dimPos1 = gradient->getPosition1();
m_pos1 = dimPos1.getPixel(size);
@ -333,16 +333,16 @@ void esvg::render::DynamicColorSpecial::generate(esvg::Document* _document) {
m_pos2 += m_viewPort.first;
}
// in the basic vertion of the gradient the color is calculated with the ration in X and Y in the bonding box associated (it is rotate with the object..
vec2 delta = m_pos2 - m_pos1;
Vector2f delta = m_pos2 - m_pos1;
if (delta.x() < 0.0f) {
m_axeX = vec2(-1.0f, 0.0f);
m_axeX = Vector2f(-1.0f, 0.0f);
} else {
m_axeX = vec2(1.0f, 0.0f);
m_axeX = Vector2f(1.0f, 0.0f);
}
if (delta.y() < 0.0f) {
m_axeY = vec2(0.0f, -1.0f);
m_axeY = Vector2f(0.0f, -1.0f);
} else {
m_axeY = vec2(0.0f, 1.0f);
m_axeY = Vector2f(0.0f, 1.0f);
}
// Move the positions ...
m_pos1 = m_matrix * m_pos1;
@ -350,11 +350,11 @@ void esvg::render::DynamicColorSpecial::generate(esvg::Document* _document) {
m_axeX = m_matrix.applyScaleRotation(m_axeX);
m_axeY = m_matrix.applyScaleRotation(m_axeY);
// in the basic vertion of the gradient the color is calculated with the ration in X and Y in the bonding box associated (it is rotate with the object..
vec2 intersecX = getIntersect(m_pos1, m_axeX,
Vector2f intersecX = getIntersect(m_pos1, m_axeX,
m_pos2, m_axeY);
vec2 intersecY = getIntersect(m_pos1, m_axeY,
Vector2f intersecY = getIntersect(m_pos1, m_axeY,
m_pos2, m_axeX);
m_baseSize = vec2((m_pos1 - intersecX).length(),
m_baseSize = Vector2f((m_pos1 - intersecX).length(),
(m_pos1 - intersecY).length());
// get all the colors
m_data = gradient->getColors(_document);
@ -370,15 +370,15 @@ void esvg::render::DynamicColorSpecial::generate(esvg::Document* _document) {
m_unit = gradient->m_unit;
m_spread = gradient->m_spread;
Log.verbose(" viewport = {" << m_viewPort.first << "," << m_viewPort.second << "}");
vec2 size = m_viewPort.second - m_viewPort.first;
Vector2f size = m_viewPort.second - m_viewPort.first;
esvg::Dimension dimCenter = gradient->getCenter();
vec2 center = dimCenter.getPixel(size);
Vector2f center = dimCenter.getPixel(size);
if (dimCenter.getType() == esvg::distance_pourcent) {
center += m_viewPort.first;
}
esvg::Dimension dimFocal = gradient->getFocal();
vec2 focal = dimFocal.getPixel(size);
Vector2f focal = dimFocal.getPixel(size);
if (dimFocal.getType() == esvg::distance_pourcent) {
focal += m_viewPort.first;
}
@ -389,22 +389,22 @@ void esvg::render::DynamicColorSpecial::generate(esvg::Document* _document) {
m_pos2.setX(dimRadius.getPixel(size.x()));
m_pos2.setY(dimRadius.getPixel(size.y()));
m_pos2 += center;
vec2 delta = center - m_pos2;
Vector2f delta = center - m_pos2;
if (delta.x() < 0.0f) {
m_axeX = vec2(-1.0f, 0.0f);
m_axeX = Vector2f(-1.0f, 0.0f);
} else {
m_axeX = vec2(1.0f, 0.0f);
m_axeX = Vector2f(1.0f, 0.0f);
}
if (delta.y() < 0.0f) {
m_axeY = vec2(0.0f, -1.0f);
m_axeY = Vector2f(0.0f, -1.0f);
} else {
m_axeY = vec2(0.0f, 1.0f);
m_axeY = Vector2f(0.0f, 1.0f);
}
m_pos1 = center;
} else {
m_centerIsFocal = false;
m_axeX = (center - focal).safeNormalize();
m_axeY = vec2(m_axeX.y(), -m_axeX.x());
m_axeY = Vector2f(m_axeX.y(), -m_axeX.x());
m_pos2 = m_axeX * dimRadius.getPixel(size.x()) + m_axeY * dimRadius.getPixel(size.y());
m_pos2 += center;
@ -417,11 +417,11 @@ void esvg::render::DynamicColorSpecial::generate(esvg::Document* _document) {
m_axeX = m_matrix.applyScaleRotation(m_axeX);
m_axeY = m_matrix.applyScaleRotation(m_axeY);
// in the basic vertion of the gradient the color is calculated with the ration in X and Y in the bonding box associated (it is rotate with the object..
vec2 intersecX = getIntersect(m_pos1, m_axeX,
Vector2f intersecX = getIntersect(m_pos1, m_axeX,
m_pos2, m_axeY);
vec2 intersecY = getIntersect(m_pos1, m_axeY,
Vector2f intersecY = getIntersect(m_pos1, m_axeY,
m_pos2, m_axeX);
m_baseSize = vec2((intersecX - m_pos1).length(),
m_baseSize = Vector2f((intersecX - m_pos1).length(),
(intersecY - m_pos1).length());
if (m_centerIsFocal == false) {
m_focalLength = (center - m_matrix * focal).length();

32
src/org/atriasoft/esvg/render/DynamicColor.java
View File

@ -23,9 +23,9 @@ namespace esvg {
// nothing to do ...
}
virtual ~DynamicColor() {};
virtual etk::Color<float,4> getColor(const ivec2& _pos) const = 0;
virtual etk::Color<float,4> getColor(const Vector2i& _pos) const = 0;
virtual void generate(esvg::Document* _document) = 0;
virtual void setViewPort(const etk::Pair<vec2, vec2>& _viewPort) = 0;
virtual void setViewPort(const etk::Pair<Vector2f, Vector2f>& _viewPort) = 0;
};
class DynamicColorUni : public esvg::render::DynamicColor {
public:
@ -35,13 +35,13 @@ namespace esvg {
m_color(_color) {
}
virtual etk::Color<float,4> getColor(const ivec2& _pos) const {
virtual etk::Color<float,4> getColor(const Vector2i& _pos) const {
return m_color;
}
virtual void generate(esvg::Document* _document) {
// nothing to do ...
}
virtual void setViewPort(const etk::Pair<vec2, vec2>& _viewPort) {
virtual void setViewPort(const etk::Pair<Vector2f, Vector2f>& _viewPort) {
// nothing to do ...
};
};
@ -52,26 +52,26 @@ namespace esvg {
esvg::gradientUnits m_unit;
etk::String m_colorName;
mat2x3 m_matrix;
etk::Pair<vec2, vec2> m_viewPort;
vec2 m_pos1; // in radius ==> center
vec2 m_pos2; // in radius ==> radius end position
vec2 m_focal; // Specific radius
vec2 m_axeX;
vec2 m_axeY;
vec2 m_baseSize;
etk::Pair<Vector2f, Vector2f> m_viewPort;
Vector2f m_pos1; // in radius ==> center
Vector2f m_pos2; // in radius ==> radius end position
Vector2f m_focal; // Specific radius
Vector2f m_axeX;
Vector2f m_axeY;
Vector2f m_baseSize;
float m_focalLength;
bool m_clipOut;
bool m_centerIsFocal;
etk::Vector<etk::Pair<float, etk::Color<float,4>>> m_data;
List<etk::Pair<float, etk::Color<float,4>>> m_data;
public:
DynamicColorSpecial(const etk::String& _link, const mat2x3& _mtx);
virtual etk::Color<float,4> getColor(const ivec2& _pos) const;
virtual etk::Color<float,4> getColor(const Vector2i& _pos) const;
private:
etk::Color<float,4> getColorLinear(const ivec2& _pos) const;
etk::Color<float,4> getColorRadial(const ivec2& _pos) const;
etk::Color<float,4> getColorLinear(const Vector2i& _pos) const;
etk::Color<float,4> getColorRadial(const Vector2i& _pos) const;
public:
virtual void generate(esvg::Document* _document);
virtual void setViewPort(const etk::Pair<vec2, vec2>& _viewPort);
virtual void setViewPort(const etk::Pair<Vector2f, Vector2f>& _viewPort);
};
ememory::SharedPtr<DynamicColor> createColor(etk::Pair<etk::Color<float,4>, etk::String> _color, const mat2x3& _mtx);

18
src/org/atriasoft/esvg/render/Element.java
View File

@ -47,30 +47,30 @@ namespace esvg {
m_relative = _relative;
}
protected:
vec2 m_pos;
Vector2f m_pos;
public:
const vec2& getPos() const {
const Vector2f& getPos() const {
return m_pos;
}
void setPos(const vec2& _val) {
void setPos(const Vector2f& _val) {
m_pos = _val;
}
protected:
vec2 m_pos1;
Vector2f m_pos1;
public:
const vec2& getPos1() const {
const Vector2f& getPos1() const {
return m_pos1;
}
void setPos1(const vec2& _val) {
void setPos1(const Vector2f& _val) {
m_pos1 = _val;
}
protected:
vec2 m_pos2;
Vector2f m_pos2;
public:
const vec2& getPos2() const {
const Vector2f& getPos2() const {
return m_pos2;
}
void setPos2(const vec2& _val) {
void setPos2(const Vector2f& _val) {
m_pos2 = _val;
}
public:

2
src/org/atriasoft/esvg/render/ElementBezierCurveTo.cpp
View File

@ -7,7 +7,7 @@
#include <esvg/render/Element.hpp>
#include <esvg/debug.hpp>
esvg::render::ElementBezierCurveTo::ElementBezierCurveTo(bool _relative, const vec2& _pos1, const vec2& _pos):
esvg::render::ElementBezierCurveTo::ElementBezierCurveTo(bool _relative, const Vector2f& _pos1, const Vector2f& _pos):
Element(esvg::render::path_bezierCurveTo, _relative) {
m_pos = _pos;
m_pos1 = _pos1;

2
src/org/atriasoft/esvg/render/ElementBezierCurveTo.java
View File

@ -13,7 +13,7 @@ namespace esvg {
namespace render {
class ElementBezierCurveTo : public esvg::render::Element {
public:
ElementBezierCurveTo(bool _relative, const vec2& _pos1, const vec2& _pos);
ElementBezierCurveTo(bool _relative, const Vector2f& _pos1, const Vector2f& _pos);
public:
virtual etk::String display() const;
};

2
src/org/atriasoft/esvg/render/ElementBezierSmoothCurveTo.cpp
View File

@ -7,7 +7,7 @@
#include <esvg/render/Element.hpp>
#include <esvg/debug.hpp>
esvg::render::ElementBezierSmoothCurveTo::ElementBezierSmoothCurveTo(bool _relative, const vec2& _pos):
esvg::render::ElementBezierSmoothCurveTo::ElementBezierSmoothCurveTo(bool _relative, const Vector2f& _pos):
Element(esvg::render::path_bezierSmoothCurveTo, _relative) {
m_pos = _pos;
}

2
src/org/atriasoft/esvg/render/ElementBezierSmoothCurveTo.java
View File

@ -13,7 +13,7 @@ namespace esvg {
namespace render {
class ElementBezierSmoothCurveTo : public esvg::render::Element {
public:
ElementBezierSmoothCurveTo(bool _relative, const vec2& _pos);
ElementBezierSmoothCurveTo(bool _relative, const Vector2f& _pos);
public:
virtual etk::String display() const;
};

2
src/org/atriasoft/esvg/render/ElementCurveTo.cpp
View File

@ -7,7 +7,7 @@
#include <esvg/render/Element.hpp>
#include <esvg/debug.hpp>
esvg::render::ElementCurveTo::ElementCurveTo(bool _relative, const vec2& _pos1, const vec2& _pos2, const vec2& _pos):
esvg::render::ElementCurveTo::ElementCurveTo(bool _relative, const Vector2f& _pos1, const Vector2f& _pos2, const Vector2f& _pos):
Element(esvg::render::path_curveTo, _relative) {
m_pos = _pos;
m_pos1 = _pos1;

2
src/org/atriasoft/esvg/render/ElementCurveTo.java
View File

@ -12,7 +12,7 @@ namespace esvg {
namespace render {
class ElementCurveTo : public esvg::render::Element {
public:
ElementCurveTo(bool _relative, const vec2& _pos1, const vec2& _pos2, const vec2& _pos);
ElementCurveTo(bool _relative, const Vector2f& _pos1, const Vector2f& _pos2, const Vector2f& _pos);
public:
virtual etk::String display() const;
};

4
src/org/atriasoft/esvg/render/ElementElliptic.cpp
View File

@ -8,11 +8,11 @@
#include <esvg/debug.hpp>
esvg::render::ElementElliptic::ElementElliptic(bool _relative,
const vec2& _radius, // in m_vec1
const Vector2f& _radius, // in m_vec1
float _angle,
bool _largeArcFlag,
bool _sweepFlag,
const vec2& _pos):
const Vector2f& _pos):
Element(esvg::render::path_elliptic, _relative) {
m_pos1 = _radius;
m_pos = _pos;

4
src/org/atriasoft/esvg/render/ElementElliptic.java
View File

@ -18,11 +18,11 @@ namespace esvg {
bool m_sweepFlag;
public:
ElementElliptic(bool _relative,
const vec2& _radius, // in m_pos1
const Vector2f& _radius, // in m_pos1
float _angle,
bool _largeArcFlag,
bool _sweepFlag,
const vec2& _pos);
const Vector2f& _pos);
public:
virtual etk::String display() const;
};

2
src/org/atriasoft/esvg/render/ElementLineTo.cpp
View File

@ -7,7 +7,7 @@
#include <esvg/render/Element.hpp>
#include <esvg/debug.hpp>
esvg::render::ElementLineTo::ElementLineTo(bool _relative, const vec2& _pos):
esvg::render::ElementLineTo::ElementLineTo(bool _relative, const Vector2f& _pos):
Element(esvg::render::path_lineTo, _relative) {
m_pos = _pos;
}

2
src/org/atriasoft/esvg/render/ElementLineTo.java
View File

@ -13,7 +13,7 @@ namespace esvg {
namespace render {
class ElementLineTo : public esvg::render::Element {
public:
ElementLineTo(bool _relative, const vec2& _pos);
ElementLineTo(bool _relative, const Vector2f& _pos);
public:
virtual etk::String display() const;
};

2
src/org/atriasoft/esvg/render/ElementLineToH.cpp
View File

@ -9,7 +9,7 @@
esvg::render::ElementLineToH::ElementLineToH(bool _relative, float _posX):
Element(esvg::render::path_lineToH, _relative) {
m_pos = vec2(_posX, 0.0f);
m_pos = Vector2f(_posX, 0.0f);
}

2
src/org/atriasoft/esvg/render/ElementLineToV.cpp
View File

@ -9,7 +9,7 @@
esvg::render::ElementLineToV::ElementLineToV(bool _relative, float _posY):
Element(esvg::render::path_lineToV, _relative) {
m_pos = vec2(0.0f, _posY);
m_pos = Vector2f(0.0f, _posY);
}

2
src/org/atriasoft/esvg/render/ElementMoveTo.cpp
View File

@ -7,7 +7,7 @@
#include <esvg/render/Element.hpp>
#include <esvg/debug.hpp>
esvg::render::ElementMoveTo::ElementMoveTo(bool _relative, const vec2& _pos):
esvg::render::ElementMoveTo::ElementMoveTo(bool _relative, const Vector2f& _pos):
Element(esvg::render::path_moveTo, _relative) {
m_pos = _pos;
}

2
src/org/atriasoft/esvg/render/ElementMoveTo.java
View File

@ -13,7 +13,7 @@ namespace esvg {
namespace render {
class ElementMoveTo : public esvg::render::Element {
public:
ElementMoveTo(bool _relative, const vec2& _pos);
ElementMoveTo(bool _relative, const Vector2f& _pos);
public:
virtual etk::String display() const;
};

2
src/org/atriasoft/esvg/render/ElementSmoothCurveTo.cpp
View File

@ -7,7 +7,7 @@
#include <esvg/render/Element.hpp>
#include <esvg/debug.hpp>
esvg::render::ElementSmoothCurveTo::ElementSmoothCurveTo(bool _relative, const vec2& _pos2, const vec2& _pos):
esvg::render::ElementSmoothCurveTo::ElementSmoothCurveTo(bool _relative, const Vector2f& _pos2, const Vector2f& _pos):
Element(esvg::render::path_smoothCurveTo, _relative) {
m_pos = _pos;
m_pos2 = _pos2;

2
src/org/atriasoft/esvg/render/ElementSmoothCurveTo.java
View File

@ -13,7 +13,7 @@ namespace esvg {
namespace render {
class ElementSmoothCurveTo : public esvg::render::Element {
public:
ElementSmoothCurveTo(bool _relative, const vec2& _pos2, const vec2& _pos);
ElementSmoothCurveTo(bool _relative, const Vector2f& _pos2, const Vector2f& _pos);
public:
virtual etk::String display() const;
};

162
src/org/atriasoft/esvg/render/Path.cpp
View File

@ -19,11 +19,11 @@ void esvg::render::Path::close(bool _relative) {
m_listElement.pushBack(ememory::makeShared<esvg::render::ElementClose>(_relative));
}
void esvg::render::Path::moveTo(bool _relative, const vec2& _pos) {
void esvg::render::Path::moveTo(bool _relative, const Vector2f& _pos) {
m_listElement.pushBack(ememory::makeShared<esvg::render::ElementMoveTo>(_relative, _pos));
}
void esvg::render::Path::lineTo(bool _relative, const vec2& _pos) {
void esvg::render::Path::lineTo(bool _relative, const Vector2f& _pos) {
m_listElement.pushBack(ememory::makeShared<esvg::render::ElementLineTo>(_relative, _pos));
}
@ -35,28 +35,28 @@ void esvg::render::Path::lineToV(bool _relative, float _posY) {
m_listElement.pushBack(ememory::makeShared<esvg::render::ElementLineToV>(_relative, _posY));
}
void esvg::render::Path::curveTo(bool _relative, const vec2& _pos1, const vec2& _pos2, const vec2& _pos) {
void esvg::render::Path::curveTo(bool _relative, const Vector2f& _pos1, const Vector2f& _pos2, const Vector2f& _pos) {
m_listElement.pushBack(ememory::makeShared<esvg::render::ElementCurveTo>(_relative, _pos1, _pos2, _pos));
}
void esvg::render::Path::smoothCurveTo(bool _relative, const vec2& _pos2, const vec2& _pos) {
void esvg::render::Path::smoothCurveTo(bool _relative, const Vector2f& _pos2, const Vector2f& _pos) {
m_listElement.pushBack(ememory::makeShared<esvg::render::ElementSmoothCurveTo>(_relative, _pos2, _pos));
}
void esvg::render::Path::bezierCurveTo(bool _relative, const vec2& _pos1, const vec2& _pos) {
void esvg::render::Path::bezierCurveTo(bool _relative, const Vector2f& _pos1, const Vector2f& _pos) {
m_listElement.pushBack(ememory::makeShared<esvg::render::ElementBezierCurveTo>(_relative, _pos1, _pos));
}
void esvg::render::Path::bezierSmoothCurveTo(bool _relative, const vec2& _pos) {
void esvg::render::Path::bezierSmoothCurveTo(bool _relative, const Vector2f& _pos) {
m_listElement.pushBack(ememory::makeShared<esvg::render::ElementBezierSmoothCurveTo>(_relative, _pos));
}
void esvg::render::Path::ellipticTo(bool _relative,
const vec2& _radius,
const Vector2f& _radius,
float _angle,
bool _largeArcFlag,
bool _sweepFlag,
const vec2& _pos) {
const Vector2f& _pos) {
m_listElement.pushBack(ememory::makeShared<esvg::render::ElementElliptic>(_relative, _radius, _angle, _largeArcFlag, _sweepFlag, _pos));
}
@ -79,23 +79,23 @@ void esvg::render::Path::display(int32_t _spacing) {
}
void interpolateCubicBezier(etk::Vector<esvg::render::Point>& _listPoint,
void interpolateCubicBezier(List<esvg::render::Point>& _listPoint,
int32_t _recurtionMax,
float _threshold,
vec2 _pos1,
vec2 _pos2,
vec2 _pos3,
vec2 _pos4,
Vector2f _pos1,
Vector2f _pos2,
Vector2f _pos3,
Vector2f _pos4,
int32_t _level,
enum esvg::render::Point::type _type) {
if (_level > _recurtionMax) {
return;
}
vec2 pos12 = (_pos1+_pos2)*0.5f;
vec2 pos23 = (_pos2+_pos3)*0.5f;
vec2 pos34 = (_pos3+_pos4)*0.5f;
Vector2f pos12 = (_pos1+_pos2)*0.5f;
Vector2f pos23 = (_pos2+_pos3)*0.5f;
Vector2f pos34 = (_pos3+_pos4)*0.5f;
vec2 delta = _pos4 - _pos1;
Vector2f delta = _pos4 - _pos1;
#ifndef __STDCPP_LLVM__
float distance2 = etk::abs(((_pos2.x() - _pos4.x()) * delta.y() - (_pos2.y() - _pos4.y()) * delta.x() ));
float distance3 = etk::abs(((_pos3.x() - _pos4.x()) * delta.y() - (_pos3.y() - _pos4.y()) * delta.x() ));
@ -108,15 +108,15 @@ void interpolateCubicBezier(etk::Vector<esvg::render::Point>& _listPoint,
_listPoint.pushBack(esvg::render::Point(_pos4, _type) );
return;
}
vec2 pos123 = (pos12+pos23)*0.5f;
vec2 pos234 = (pos23+pos34)*0.5f;
vec2 pos1234 = (pos123+pos234)*0.5f;
Vector2f pos123 = (pos12+pos23)*0.5f;
Vector2f pos234 = (pos23+pos34)*0.5f;
Vector2f pos1234 = (pos123+pos234)*0.5f;
interpolateCubicBezier(_listPoint, _recurtionMax, _threshold, _pos1, pos12, pos123, pos1234, _level+1, esvg::render::Point::type::interpolation);
interpolateCubicBezier(_listPoint, _recurtionMax, _threshold, pos1234, pos234, pos34, _pos4, _level+1, _type);
}
static float vectorAngle(vec2 _uuu, vec2 _vvv) {
static float vectorAngle(Vector2f _uuu, Vector2f _vvv) {
_uuu.safeNormalize();
_vvv.safeNormalize();
return atan2(_uuu.cross(_vvv), _uuu.dot(_vvv));
@ -125,9 +125,9 @@ static float vectorAngle(vec2 _uuu, vec2 _vvv) {
esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, int32_t _recurtionMax, float _threshold) {
Log.verbose(spacingDist(_level) << "Generate List Points ... from a path");
esvg::render::PointList out;
etk::Vector<esvg::render::Point> tmpListPoint;
vec2 lastPosition(0.0f, 0.0f);
vec2 lastAngle(0.0f, 0.0f);
List<esvg::render::Point> tmpListPoint;
Vector2f lastPosition(0.0f, 0.0f);
Vector2f lastAngle(0.0f, 0.0f);
int32_t lastPointId = -1;
bool PathStart = false;
// Foreach element, we move in the path:
@ -147,7 +147,7 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
tmpListPoint.clear();
}
}
lastAngle = vec2(0.0f, 0.0f);
lastAngle = Vector2f(0.0f, 0.0f);
// nothing alse to do ...
break;
case esvg::render::path_close:
@ -158,7 +158,7 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
// find the previous tart of the path ...
tmpListPoint.front().m_type = esvg::render::Point::type::join;
// Remove the last point if it is the same position...
vec2 delta = (tmpListPoint.front().m_pos - tmpListPoint.back().m_pos).absolute();
Vector2f delta = (tmpListPoint.front().m_pos - tmpListPoint.back().m_pos).absolute();
if ( delta.x() <= 0.00001
&& delta.y() <= 0.00001) {
tmpListPoint.popBack();
@ -168,7 +168,7 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
tmpListPoint.clear();
}
}
lastAngle = vec2(0.0f, 0.0f);
lastAngle = Vector2f(0.0f, 0.0f);
// nothing alse to do ...
break;
case esvg::render::path_moveTo:
@ -180,7 +180,7 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
}
// create a new one
if (it->getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
lastPosition = Vector2f(0.0f, 0.0f);
}
lastPosition += it->getPos();
tmpListPoint.pushBack(esvg::render::Point(lastPosition, esvg::render::Point::type::start));
@ -192,7 +192,7 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
tmpListPoint.pushBack(esvg::render::Point(lastPosition, esvg::render::Point::type::start));
}
if (it->getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
lastPosition = Vector2f(0.0f, 0.0f);
}
lastPosition += it->getPos();
tmpListPoint.pushBack(esvg::render::Point(lastPosition, esvg::render::Point::type::join));
@ -204,7 +204,7 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
tmpListPoint.pushBack(esvg::render::Point(lastPosition, esvg::render::Point::type::start));
}
if (it->getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
lastPosition = Vector2f(0.0f, 0.0f);
}
lastPosition += it->getPos();
tmpListPoint.pushBack(esvg::render::Point(lastPosition, esvg::render::Point::type::join));
@ -216,7 +216,7 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
tmpListPoint.pushBack(esvg::render::Point(lastPosition, esvg::render::Point::type::start));
}
if (it->getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
lastPosition = Vector2f(0.0f, 0.0f);
}
lastPosition += it->getPos();
tmpListPoint.pushBack(esvg::render::Point(lastPosition, esvg::render::Point::type::join));
@ -228,13 +228,13 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
tmpListPoint.pushBack(esvg::render::Point(lastPosition, esvg::render::Point::type::join));
}
{
vec2 lastPosStore(lastPosition);
Vector2f lastPosStore(lastPosition);
if (it->getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
lastPosition = Vector2f(0.0f, 0.0f);
}
vec2 pos1 = lastPosition + it->getPos1();
vec2 pos2 = lastPosition + it->getPos2();
vec2 pos = lastPosition + it->getPos();
Vector2f pos1 = lastPosition + it->getPos1();
Vector2f pos2 = lastPosition + it->getPos2();
Vector2f pos = lastPosition + it->getPos();
interpolateCubicBezier(tmpListPoint,
_recurtionMax,
_threshold,
@ -254,14 +254,14 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
tmpListPoint.pushBack(esvg::render::Point(lastPosition, esvg::render::Point::type::join));
}
{
vec2 lastPosStore(lastPosition);
Vector2f lastPosStore(lastPosition);
if (it->getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
lastPosition = Vector2f(0.0f, 0.0f);
}
vec2 pos2 = lastPosition + it->getPos2();
vec2 pos = lastPosition + it->getPos();
Vector2f pos2 = lastPosition + it->getPos2();
Vector2f pos = lastPosition + it->getPos();
// generate Pos 1
vec2 pos1 = lastPosStore*2.0f - lastAngle;
Vector2f pos1 = lastPosStore*2.0f - lastAngle;
interpolateCubicBezier(tmpListPoint,
_recurtionMax,
_threshold,
@ -281,15 +281,15 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
tmpListPoint.pushBack(esvg::render::Point(lastPosition, esvg::render::Point::type::join));
}
{
vec2 lastPosStore(lastPosition);
Vector2f lastPosStore(lastPosition);
if (it->getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
lastPosition = Vector2f(0.0f, 0.0f);
}
vec2 pos = lastPosition + it->getPos();
vec2 tmp1 = lastPosition + it->getPos1();
Vector2f pos = lastPosition + it->getPos();
Vector2f tmp1 = lastPosition + it->getPos1();
// generate pos1 and pos2
vec2 pos1 = lastPosStore + (tmp1 - lastPosStore)*0.666666666f;
vec2 pos2 = pos + (tmp1 - pos)*0.666666666f;
Vector2f pos1 = lastPosStore + (tmp1 - lastPosStore)*0.666666666f;
Vector2f pos2 = pos + (tmp1 - pos)*0.666666666f;
interpolateCubicBezier(tmpListPoint,
_recurtionMax,
_threshold,
@ -309,15 +309,15 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
tmpListPoint.pushBack(esvg::render::Point(lastPosition, esvg::render::Point::type::join));
}
{
vec2 lastPosStore(lastPosition);
Vector2f lastPosStore(lastPosition);
if (it->getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
lastPosition = Vector2f(0.0f, 0.0f);
}
vec2 pos = lastPosition + it->getPos();
vec2 tmp1 = lastPosStore*2.0f - lastAngle;
Vector2f pos = lastPosition + it->getPos();
Vector2f tmp1 = lastPosStore*2.0f - lastAngle;
// generate pos1 and pos2
vec2 pos1 = lastPosStore + (tmp1 - lastPosStore)*0.666666666f;
vec2 pos2 = pos + (tmp1 - pos)*0.66666666f;
Vector2f pos1 = lastPosStore + (tmp1 - lastPosStore)*0.666666666f;
Vector2f pos2 = pos + (tmp1 - pos)*0.66666666f;
interpolateCubicBezier(tmpListPoint,
_recurtionMax,
_threshold,
@ -339,24 +339,24 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
{
ememory::SharedPtr<esvg::render::ElementElliptic> tmpIt(ememory::dynamicPointerCast<esvg::render::ElementElliptic>(it));
float angle = tmpIt->m_angle * (M_PI / 180.0);
ESVG_TODO(spacingDist(_level+1) << " Elliptic arc: radius=" << tmpIt->getPos1());
ESVG_TODO(spacingDist(_level+1) << " angle=" << tmpIt->m_angle);
ESVG_TODO(spacingDist(_level+1) << " m_largeArcFlag=" << tmpIt->m_largeArcFlag);
ESVG_TODO(spacingDist(_level+1) << " m_sweepFlag=" << tmpIt->m_sweepFlag);
Log.todo(spacingDist(_level+1) << " Elliptic arc: radius=" << tmpIt->getPos1());
Log.todo(spacingDist(_level+1) << " angle=" << tmpIt->m_angle);
Log.todo(spacingDist(_level+1) << " m_largeArcFlag=" << tmpIt->m_largeArcFlag);
Log.todo(spacingDist(_level+1) << " m_sweepFlag=" << tmpIt->m_sweepFlag);
vec2 lastPosStore(lastPosition);
Vector2f lastPosStore(lastPosition);
if (it->getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
lastPosition = Vector2f(0.0f, 0.0f);
}
vec2 pos = lastPosition + it->getPos();
Vector2f pos = lastPosition + it->getPos();
float rotationX = tmpIt->m_angle * (M_PI / 180.0);
vec2 radius = tmpIt->getPos1();
Vector2f radius = tmpIt->getPos1();
#ifdef DEBUG
m_debugInformation.addSegment(lastPosStore, pos);
#endif
vec2 delta = lastPosStore - pos;
Vector2f delta = lastPosStore - pos;
float ddd = delta.length();
if ( ddd < 1e-6f
|| radius.x() < 1e-6f
@ -372,7 +372,7 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
// procedure describe here : http://www.w3.org/TR/SVG11/implnote.html#ArcConversionCenterToEndpoint
// Compute delta'
mat2x3 matrixRotationCenter = etk::mat2x3Rotate(-rotationX);
vec2 deltaPrim = matrixRotationCenter * (delta*0.5f);
Vector2f deltaPrim = matrixRotationCenter * (delta*0.5f);
ddd = (deltaPrim.x()*deltaPrim.x())/(radius.x()*radius.x())
+ (deltaPrim.y()*deltaPrim.y())/(radius.y()*radius.y());
if (ddd > 1.0f) {
@ -403,24 +403,24 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
if (tmpIt->m_largeArcFlag == tmpIt->m_sweepFlag) {
sss *= -1.0f;
}
vec2 centerPrime(sss * radius.x() * deltaPrim.y() / radius.y(),
Vector2f centerPrime(sss * radius.x() * deltaPrim.y() / radius.y(),
sss * -radius.y() * deltaPrim.x() / radius.x());
// Compute center from center'
mat2x3 matrix = etk::mat2x3Rotate(rotationX);
vec2 center = (lastPosStore + pos)*0.5f + matrix*centerPrime;
Vector2f center = (lastPosStore + pos)*0.5f + matrix*centerPrime;
#ifdef DEBUG
m_debugInformation.addSegment(center-vec2(3.0,3.0), center+vec2(3.0,3.0));
m_debugInformation.addSegment(center-vec2(3.0,-3.0), center+vec2(3.0,-3.0));
m_debugInformation.addSegment(center-Vector2f(3.0,3.0), center+Vector2f(3.0,3.0));
m_debugInformation.addSegment(center-Vector2f(3.0,-3.0), center+Vector2f(3.0,-3.0));
#endif
// Calculate theta1, and delta theta.
vec2 vectorA = (deltaPrim - centerPrime) / radius;
vec2 vectorB = (deltaPrim + centerPrime) / radius * -1.0f;
Vector2f vectorA = (deltaPrim - centerPrime) / radius;
Vector2f vectorB = (deltaPrim + centerPrime) / radius * -1.0f;
#ifdef DEBUG
m_debugInformation.addSegment(center, center+vectorA*radius.x());
m_debugInformation.addSegment(center, center+vectorB*radius.y());
#endif
// Initial angle
float theta1 = vectorAngle(vec2(1.0f,0.0f), vectorA);
float theta1 = vectorAngle(Vector2f(1.0f,0.0f), vectorA);
// Delta angle
float deltaTheta = vectorAngle(vectorA, vectorB);
// special case of invert angle...
@ -455,27 +455,27 @@ esvg::render::PointList esvg::render::Path::generateListPoints(int32_t _level, i
if (deltaTheta < 0.0f) {
kappa = -kappa;
}
vec2 pointPosPrevious(0.0,0.0);
vec2 tangentPrevious(0.0,0.0);
Vector2f pointPosPrevious(0.0,0.0);
Vector2f tangentPrevious(0.0,0.0);
for (int32_t iii=0; iii<=ndivs; ++iii) {
float a = theta1 + deltaTheta * (float(iii)/(float)ndivs);
#ifndef __STDCPP_LLVM__
delta = vec2(etk::cos(a), etk::sin(a));
delta = Vector2f(etk::cos(a), etk::sin(a));
#else
delta = vec2(cosf(a), sinf(a));
delta = Vector2f(cosf(a), sinf(a));
#endif
// position
vec2 pointPos = matrix * vec2(delta.x()*radius.x(), delta.y()*radius.y());
Vector2f pointPos = matrix * Vector2f(delta.x()*radius.x(), delta.y()*radius.y());
// tangent
vec2 tangent = matrix.applyScaleRotation(vec2(-delta.y()*radius.x() * kappa, delta.x()*radius.y() * kappa));
Vector2f tangent = matrix.applyScaleRotation(Vector2f(-delta.y()*radius.x() * kappa, delta.x()*radius.y() * kappa));
if (iii > 0) {
vec2 zlastPosStore(lastPosition);
Vector2f zlastPosStore(lastPosition);
if (it->getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
lastPosition = Vector2f(0.0f, 0.0f);
}
vec2 zpos1 = pointPosPrevious + tangentPrevious;
vec2 zpos2 = pointPos - tangent;
vec2 zpos = pointPos;
Vector2f zpos1 = pointPosPrevious + tangentPrevious;
Vector2f zpos2 = pointPos - tangent;
Vector2f zpos = pointPos;
interpolateCubicBezier(tmpListPoint,
_recurtionMax,
_threshold,

18
src/org/atriasoft/esvg/render/Path.java
View File

@ -18,7 +18,7 @@ namespace esvg {
namespace render {
class Path {
public:
etk::Vector<ememory::SharedPtr<esvg::render::Element>> m_listElement;
List<ememory::SharedPtr<esvg::render::Element>> m_listElement;
#ifdef DEBUG
esvg::render::SegmentList m_debugInformation;
#endif
@ -33,20 +33,20 @@ namespace esvg {
void clear();
void stop();
void close(bool _relative=false);
void moveTo(bool _relative, const vec2& _pos);
void lineTo(bool _relative, const vec2& _pos);
void moveTo(bool _relative, const Vector2f& _pos);
void lineTo(bool _relative, const Vector2f& _pos);
void lineToH(bool _relative, float _posX);
void lineToV(bool _relative, float _posY);
void curveTo(bool _relative, const vec2& _pos1, const vec2& _pos2, const vec2& _pos);
void smoothCurveTo(bool _relative, const vec2& _pos2, const vec2& _pos);
void bezierCurveTo(bool _relative, const vec2& _pos1, const vec2& _pos);
void bezierSmoothCurveTo(bool _relative, const vec2& _pos);
void curveTo(bool _relative, const Vector2f& _pos1, const Vector2f& _pos2, const Vector2f& _pos);
void smoothCurveTo(bool _relative, const Vector2f& _pos2, const Vector2f& _pos);
void bezierCurveTo(bool _relative, const Vector2f& _pos1, const Vector2f& _pos);
void bezierSmoothCurveTo(bool _relative, const Vector2f& _pos);
void ellipticTo(bool _relative,
const vec2& _radius,
const Vector2f& _radius,
float _angle,
bool _largeArcFlag,
bool _sweepFlag,
const vec2& _pos);
const Vector2f& _pos);
void display(int32_t _spacing);
esvg::render::PointList generateListPoints(int32_t _level, int32_t _recurtionMax = 10, float _threshold = 0.25f);
};

2
src/org/atriasoft/esvg/render/Point.cpp
View File

@ -24,7 +24,7 @@ void esvg::render::Point::setEndPath() {
m_type = esvg::render::Point::type::stop;
}
void esvg::render::Point::normalize(const vec2& _nextPoint) {
void esvg::render::Point::normalize(const Vector2f& _nextPoint) {
m_delta = _nextPoint - m_pos;
m_len = m_delta.length();
}

20
src/org/atriasoft/esvg/render/Point.java
View File

@ -22,28 +22,28 @@ namespace esvg {
};
public:
// TODO : Clean all element here ...
vec2 m_pos; //!< position of the point
Vector2f m_pos; //!< position of the point
enum esvg::render::Point::type m_type;
vec2 m_miterAxe;
vec2 m_orthoAxePrevious;
vec2 m_orthoAxeNext;
vec2 m_posPrevious;
vec2 m_posNext;
vec2 m_delta;
Vector2f m_miterAxe;
Vector2f m_orthoAxePrevious;
Vector2f m_orthoAxeNext;
Vector2f m_posPrevious;
Vector2f m_posNext;
Vector2f m_delta;
float m_len;
// TODO: Update etk::Vector to support not having it ...
// TODO: Update List to support not having it ...
Point() :
m_pos(0,0),
m_type(esvg::render::Point::type::join) {
// nothing to do ...
}
Point(const vec2& _pos, enum esvg::render::Point::type _type = esvg::render::Point::type::join) :
Point(const Vector2f& _pos, enum esvg::render::Point::type _type = esvg::render::Point::type::join) :
m_pos(_pos),
m_type(_type) {
// nothing to do ...
}
void setEndPath();
void normalize(const vec2& _nextPoint);
void normalize(const Vector2f& _nextPoint);
};
}
}

6
src/org/atriasoft/esvg/render/PointList.cpp
View File

@ -11,7 +11,7 @@ esvg::render::PointList::PointList() {
// nothing to do ...
}
void esvg::render::PointList::addList(etk::Vector<esvg::render::Point>& _list) {
void esvg::render::PointList::addList(List<esvg::render::Point>& _list) {
m_data.pushBack(_list);
// TODO : Add a checker of correct list ...
}
@ -24,8 +24,8 @@ void esvg::render::PointList::applyMatrix(const mat2x3& _transformationMatrix) {
}
}
etk::Pair<vec2, vec2> esvg::render::PointList::getViewPort() {
etk::Pair<vec2, vec2> out(vec2(9999999999.0,9999999999.0),vec2(-9999999999.0,-9999999999.0));
etk::Pair<Vector2f, Vector2f> esvg::render::PointList::getViewPort() {
etk::Pair<Vector2f, Vector2f> out(Vector2f(9999999999.0,9999999999.0),Vector2f(-9999999999.0,-9999999999.0));
for (auto &it : m_data) {
for (auto &it2 : it) {
out.first.setMin(it2.m_pos);

6
src/org/atriasoft/esvg/render/PointList.java
View File

@ -16,13 +16,13 @@ namespace esvg {
namespace render {
class PointList {
public:
etk::Vector<etk::Vector<esvg::render::Point>> m_data;
List<List<esvg::render::Point>> m_data;
public:
PointList();
void addList(etk::Vector<esvg::render::Point>& _list);
void addList(List<esvg::render::Point>& _list);
void display();
void applyMatrix(const mat2x3& _transformationMatrix);
etk::Pair<vec2, vec2> getViewPort();
etk::Pair<Vector2f, Vector2f> getViewPort();
};
}
}

2
src/org/atriasoft/esvg/render/Scanline.java
View File

@ -12,7 +12,7 @@ namespace esvg {
namespace render {
class Scanline {
private:
etk::Vector<float> m_data;
List<float> m_data;
public:
// constructor :
Scanline(size_t _size=32);

8
src/org/atriasoft/esvg/render/Segment.cpp
View File

@ -8,12 +8,12 @@
#include <esvg/debug.hpp>
esvg::render::Segment::Segment() {
p0 = vec2(0,0);
p1 = vec2(0,0);
p0 = Vector2f(0,0);
p1 = Vector2f(0,0);
direction = 0;
}
esvg::render::Segment::Segment(const vec2& _p0, const vec2& _p1) {
esvg::render::Segment::Segment(const Vector2f& _p0, const Vector2f& _p1) {
// segment register all time the lower at P0n then we need to register the sens of the path
p0 = _p0;
p1 = _p1;
@ -30,7 +30,7 @@ void esvg::render::Segment::createDirection() {
if (p0.y() < p1.y()) {
direction = 1; // direction like clock
} else {
vec2 tmp(p0);
Vector2f tmp(p0);
p0 = p1;
p1 = tmp;
direction = -1; // direction like anti-clock

8
src/org/atriasoft/esvg/render/Segment.java
View File

@ -13,11 +13,11 @@ namespace esvg {
namespace render {
class Segment {
public:
// TODO: Update etk::Vector to support not having it ...
// TODO: Update List to support not having it ...
Segment();
Segment(const vec2& _p0, const vec2& _p1);
vec2 p0;
vec2 p1;
Segment(const Vector2f& _p0, const Vector2f& _p1);
Vector2f p0;
Vector2f p1;
int32_t direction;
void applyMatrix(const mat2x3& _transformationMatrix);
void createDirection();

108
src/org/atriasoft/esvg/render/SegmentList.cpp
View File

@ -12,7 +12,7 @@ esvg::render::SegmentList::SegmentList() {
}
#ifdef DEBUG
void esvg::render::SegmentList::addSegment(const vec2& _pos0, const vec2& _pos1) {
void esvg::render::SegmentList::addSegment(const Vector2f& _pos0, const Vector2f& _pos1) {
m_data.pushBack(Segment(_pos0, _pos1));
}
#endif
@ -36,8 +36,8 @@ void esvg::render::SegmentList::addSegment(const esvg::render::Point& _pos0, con
m_data.pushBack(Segment(_pos0.m_pos, _pos1.m_pos));
}
etk::Pair<vec2, vec2> esvg::render::SegmentList::getViewPort() {
etk::Pair<vec2, vec2> out(vec2(9999999999.0,9999999999.0),vec2(-9999999999.0,-9999999999.0));
etk::Pair<Vector2f, Vector2f> esvg::render::SegmentList::getViewPort() {
etk::Pair<Vector2f, Vector2f> out(Vector2f(9999999999.0,9999999999.0),Vector2f(-9999999999.0,-9999999999.0));
for (auto &it : m_data) {
out.first.setMin(it.p0);
out.second.setMax(it.p0);
@ -57,10 +57,10 @@ void esvg::render::SegmentList::createSegmentList(const esvg::render::PointList&
}
}
static vec2 getIntersect(const vec2& _point1,
const vec2& _vect1,
const vec2& _point2,
const vec2& _vect2) {
static Vector2f getIntersect(const Vector2f& _point1,
const Vector2f& _vect1,
const Vector2f& _point2,
const Vector2f& _vect2) {
float diviseur = _vect1.x() * _vect2.y() - _vect1.y() * _vect2.x();
if(diviseur != 0.0f) {
float mmm = ( _vect1.x() * _point1.y()
@ -68,15 +68,15 @@ static vec2 getIntersect(const vec2& _point1,
- _vect1.y() * _point1.x()
+ _vect1.y() * _point2.x()
) / diviseur;
return vec2(_point2 + _vect2 * mmm);
return Vector2f(_point2 + _vect2 * mmm);
}
Log.error("Get divider / 0.0f");
return _point2;
}
void esvg::render::SegmentList::createSegmentListStroke(const vec2& _point1,
const vec2& _point2,
const vec2& _center,
void esvg::render::SegmentList::createSegmentListStroke(const Vector2f& _point1,
const Vector2f& _point2,
const Vector2f& _center,
float _width,
bool _isStart) {
int32_t nbDot = int32_t(_width);
@ -86,9 +86,9 @@ void esvg::render::SegmentList::createSegmentListStroke(const vec2& _point1,
float angleToDraw = acos((_point1 - _center).safeNormalize().dot((_point2 - _center).safeNormalize()));
float baseAngle = angleToDraw/float(nbDot);
float iii;
vec2 axe = (_point1 - _center).safeNormalize();
vec2 ppp1(_point1);
vec2 ppp2(_point2);
Vector2f axe = (_point1 - _center).safeNormalize();
Vector2f ppp1(_point1);
Vector2f ppp2(_point2);
for (iii=baseAngle; iii<angleToDraw; iii+=baseAngle) {
mat2x3 tmpMat;
if (_isStart == true) {
@ -96,7 +96,7 @@ void esvg::render::SegmentList::createSegmentListStroke(const vec2& _point1,
} else {
tmpMat = etk::mat2x3Rotate(iii);
}
vec2 axeRotate = tmpMat * axe;
Vector2f axeRotate = tmpMat * axe;
ppp2 = _center
+ axeRotate*_width*0.5f;
if (_isStart == true) {
@ -155,17 +155,17 @@ void esvg::render::SegmentList::createSegmentListStroke(esvg::render::PointList&
}
//Log.debug("JOIN : id : prev/curr/next : " << idPevious << "/" << idCurrent << "/" << idNext);
//Log.debug("JOIN : val : prev/curr/next : " << itListPoint[idPevious].m_pos << "/" << itListPoint[idCurrent].m_pos << "/" << itListPoint[idNext].m_pos);
vec2 vecA = itListPoint[idCurrent].m_pos - itListPoint[idPevious].m_pos;
Vector2f vecA = itListPoint[idCurrent].m_pos - itListPoint[idPevious].m_pos;
//Log.debug("JOIN : vecA : " << vecA);
vecA.safeNormalize();
vec2 vecB = itListPoint[idNext].m_pos - itListPoint[idCurrent].m_pos;
Vector2f vecB = itListPoint[idNext].m_pos - itListPoint[idCurrent].m_pos;
//Log.debug("JOIN : vecB : " << vecB);
vecB.safeNormalize();
vec2 vecC = vecA - vecB;
Vector2f vecC = vecA - vecB;
//Log.debug("JOIN : vecC : " << vecC);
if (vecC == vec2(0.0f, 0.0f)) {
if (vecC == Vector2f(0.0f, 0.0f)) {
// special case: 1 line ...
itListPoint[idCurrent].m_miterAxe = vec2(vecA.y(), vecA.x());
itListPoint[idCurrent].m_miterAxe = Vector2f(vecA.y(), vecA.x());
} else {
vecC.safeNormalize();
itListPoint[idCurrent].m_miterAxe = vecC;
@ -174,16 +174,16 @@ void esvg::render::SegmentList::createSegmentListStroke(esvg::render::PointList&
itListPoint[idCurrent].m_posNext = itListPoint[idNext].m_pos;
vecB = itListPoint[idNext].m_pos - itListPoint[idCurrent].m_pos;
vecB.safeNormalize();
itListPoint[idCurrent].m_orthoAxeNext = vec2(vecB.y(), -vecB.x());
itListPoint[idCurrent].m_orthoAxeNext = Vector2f(vecB.y(), -vecB.x());
vecB = itListPoint[idCurrent].m_pos - itListPoint[idPevious].m_pos;
vecB.safeNormalize();
itListPoint[idCurrent].m_orthoAxePrevious = vec2(vecB.y(), -vecB.x());
itListPoint[idCurrent].m_orthoAxePrevious = Vector2f(vecB.y(), -vecB.x());
//Log.debug("JOIN : miterAxe " << itListPoint[idCurrent].m_miterAxe);
} else if (itListPoint[idCurrent].m_type == esvg::render::Point::type::start) {
itListPoint[idCurrent].m_posNext = itListPoint[idNext].m_pos;
vec2 vecB = itListPoint[idNext].m_pos - itListPoint[idCurrent].m_pos;
Vector2f vecB = itListPoint[idNext].m_pos - itListPoint[idCurrent].m_pos;
vecB.safeNormalize();
itListPoint[idCurrent].m_miterAxe = vec2(vecB.y(), -vecB.x());
itListPoint[idCurrent].m_miterAxe = Vector2f(vecB.y(), -vecB.x());
itListPoint[idCurrent].m_orthoAxePrevious = itListPoint[idCurrent].m_miterAxe;
itListPoint[idCurrent].m_orthoAxeNext = itListPoint[idCurrent].m_miterAxe;
} else if (itListPoint[idCurrent].m_type == esvg::render::Point::type::stop) {
@ -192,19 +192,19 @@ void esvg::render::SegmentList::createSegmentListStroke(esvg::render::PointList&
continue;
}
itListPoint[idCurrent].m_posPrevious = itListPoint[idPevious].m_pos;
vec2 vecA = itListPoint[idCurrent].m_pos - itListPoint[idPevious].m_pos;
Vector2f vecA = itListPoint[idCurrent].m_pos - itListPoint[idPevious].m_pos;
vecA.safeNormalize();
itListPoint[idCurrent].m_miterAxe = vec2(vecA.y(), -vecA.x());
itListPoint[idCurrent].m_miterAxe = Vector2f(vecA.y(), -vecA.x());
itListPoint[idCurrent].m_orthoAxePrevious = itListPoint[idCurrent].m_miterAxe;
itListPoint[idCurrent].m_orthoAxeNext = itListPoint[idCurrent].m_miterAxe;
} else {
ESVG_TODO("Unsupported type of point ....");
Log.todo("Unsupported type of point ....");
}
}
// create segment list:
bool haveStartLine = false;
vec2 leftPoint(0,0);
vec2 rightPoint(0,0);
Vector2f leftPoint(0,0);
Vector2f rightPoint(0,0);
if (itListPoint.size() > 0) {
if (itListPoint.front().m_type == esvg::render::Point::type::join) {
const esvg::render::Point& it = itListPoint.back();
@ -227,8 +227,8 @@ void esvg::render::SegmentList::createSegmentListStroke(esvg::render::PointList&
switch (_join) {
case esvg::join_miter:
{
vec2 left = getIntersect(leftPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
vec2 right = getIntersect(rightPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
Vector2f left = getIntersect(leftPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
Vector2f right = getIntersect(rightPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
// Check the miter limit:
float limitRight = (left - it.m_pos).length() / _width * 2.0f;
float limitLeft = (right - it.m_pos).length() / _width * 2.0f;
@ -245,8 +245,8 @@ void esvg::render::SegmentList::createSegmentListStroke(esvg::render::PointList&
case esvg::join_round:
case esvg::join_bevel:
{
vec2 axePrevious = (it.m_pos-it.m_posPrevious).safeNormalize();
vec2 axeNext = (it.m_posNext - it.m_pos).safeNormalize();
Vector2f axePrevious = (it.m_pos-it.m_posPrevious).safeNormalize();
Vector2f axeNext = (it.m_posNext - it.m_pos).safeNormalize();
float cross = axePrevious.cross(axeNext);
if (cross > 0.0f) {
rightPoint = getIntersect(rightPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
@ -293,8 +293,8 @@ void esvg::render::SegmentList::createSegmentListStroke(esvg::render::PointList&
case esvg::render::Point::type::interpolation:
{
Log.verbose("Find interpolation " << it.m_pos);
vec2 left = getIntersect(leftPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
vec2 right = getIntersect(rightPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
Vector2f left = getIntersect(leftPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
Vector2f right = getIntersect(rightPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
//Draw from previous point:
addSegment(leftPoint, left);
Log.verbose(" segment :" << leftPoint << " -> " << left);
@ -309,8 +309,8 @@ void esvg::render::SegmentList::createSegmentListStroke(esvg::render::PointList&
switch (_join) {
case esvg::join_miter:
{
vec2 left = getIntersect(leftPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
vec2 right = getIntersect(rightPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
Vector2f left = getIntersect(leftPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
Vector2f right = getIntersect(rightPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
// Check the miter limit:
float limitRight = (left - it.m_pos).length() / _width * 2.0f;
float limitLeft = (right - it.m_pos).length() / _width * 2.0f;
@ -333,14 +333,14 @@ void esvg::render::SegmentList::createSegmentListStroke(esvg::render::PointList&
case esvg::join_round:
case esvg::join_bevel:
{
vec2 axePrevious = (it.m_pos-it.m_posPrevious).safeNormalize();
vec2 axeNext = (it.m_posNext - it.m_pos).safeNormalize();
Vector2f axePrevious = (it.m_pos-it.m_posPrevious).safeNormalize();
Vector2f axeNext = (it.m_posNext - it.m_pos).safeNormalize();
float cross = axePrevious.cross(axeNext);
if (cross > 0.0f) {
vec2 right = getIntersect(rightPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
vec2 left1 = it.m_pos
Vector2f right = getIntersect(rightPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
Vector2f left1 = it.m_pos
+ it.m_orthoAxePrevious*_width*0.5f;
vec2 left2 = it.m_pos
Vector2f left2 = it.m_pos
+ it.m_orthoAxeNext*_width*0.5f;
//Draw from previous point:
addSegment(leftPoint, left1);
@ -361,10 +361,10 @@ void esvg::render::SegmentList::createSegmentListStroke(esvg::render::PointList&
leftPoint = left2;
rightPoint = right;
} else {
vec2 left = getIntersect(leftPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
vec2 right1 = it.m_pos
Vector2f left = getIntersect(leftPoint, it.m_pos-it.m_posPrevious, it.m_pos, it.m_miterAxe);
Vector2f right1 = it.m_pos
- it.m_orthoAxePrevious*_width*0.5f;
vec2 right2 = it.m_pos
Vector2f right2 = it.m_pos
- it.m_orthoAxeNext*_width*0.5f;//Draw from previous point:
addSegment(leftPoint, left);
Log.verbose(" segment :" << leftPoint << " -> " << left);
@ -393,8 +393,8 @@ void esvg::render::SegmentList::createSegmentListStroke(esvg::render::PointList&
}
}
void esvg::render::SegmentList::startStopPoint(vec2& _leftPoint,
vec2& _rightPoint,
void esvg::render::SegmentList::startStopPoint(Vector2f& _leftPoint,
Vector2f& _rightPoint,
const esvg::render::Point& _point,
enum esvg::cap _cap,
float _width,
@ -402,9 +402,9 @@ void esvg::render::SegmentList::startStopPoint(vec2& _leftPoint,
switch (_cap) {
case esvg::cap_butt:
{
vec2 left = _point.m_pos
Vector2f left = _point.m_pos
+ _point.m_miterAxe*_width*0.5f;
vec2 right = _point.m_pos
Vector2f right = _point.m_pos
- _point.m_miterAxe*_width*0.5f;
if (_isStart == false) {
//Draw from previous point:
@ -427,9 +427,9 @@ void esvg::render::SegmentList::startStopPoint(vec2& _leftPoint,
case esvg::cap_round:
{
if (_isStart == false) {
vec2 left = _point.m_pos
Vector2f left = _point.m_pos
+ _point.m_miterAxe*_width*0.5f;
vec2 right = _point.m_pos
Vector2f right = _point.m_pos
- _point.m_miterAxe*_width*0.5f;
if (_isStart == false) {
//Draw from previous point:
@ -460,15 +460,15 @@ void esvg::render::SegmentList::startStopPoint(vec2& _leftPoint,
break;
case esvg::cap_square:
{
vec2 nextAxe;
Vector2f nextAxe;
if (_isStart == true) {
nextAxe = _point.m_posNext - _point.m_pos;
} else {
nextAxe = _point.m_posPrevious - _point.m_pos;
}
vec2 left = _point.m_pos
Vector2f left = _point.m_pos
+ _point.m_miterAxe*_width*0.5f;
vec2 right = _point.m_pos
Vector2f right = _point.m_pos
- _point.m_miterAxe*_width*0.5f;
mat2x3 tmpMat = etk::mat2x3Translate(nextAxe.safeNormalize()*_width*-0.5f);
left = tmpMat*left;

16
src/org/atriasoft/esvg/render/SegmentList.java
View File

@ -16,11 +16,11 @@ namespace esvg {
namespace render {
class SegmentList {
public:
etk::Vector<esvg::render::Segment> m_data;
List<esvg::render::Segment> m_data;
public:
SegmentList();
#ifdef DEBUG
void addSegment(const vec2& _pos0, const vec2& _pos1);
void addSegment(const Vector2f& _pos0, const Vector2f& _pos1);
#endif
void addSegment(const esvg::render::Point& _pos0, const esvg::render::Point& _pos1);
void addSegment(const esvg::render::Point& _pos0, const esvg::render::Point& _pos1, bool _disableHorizontal);
@ -31,19 +31,19 @@ namespace esvg {
enum esvg::join _join,
float _miterLimit);
private:
void startStopPoint(vec2& _leftPoint,
vec2& _rightPoint,
void startStopPoint(Vector2f& _leftPoint,
Vector2f& _rightPoint,
const esvg::render::Point& _point,
enum esvg::cap _cap,
float _width,
bool _isStart);
void createSegmentListStroke(const vec2& _point1,
const vec2& _point2,
const vec2& _center,
void createSegmentListStroke(const Vector2f& _point1,
const Vector2f& _point2,
const Vector2f& _center,
float _width,
bool _isStart);
public:
etk::Pair<vec2, vec2> getViewPort();
etk::Pair<Vector2f, Vector2f> getViewPort();
void applyMatrix(const mat2x3& _transformationMatrix);
};
}

20
src/org/atriasoft/esvg/render/Weight.cpp
View File

@ -13,7 +13,7 @@ esvg::render::Weight::Weight() :
}
esvg::render::Weight::Weight(const ivec2& _size) :
esvg::render::Weight::Weight(const Vector2i& _size) :
m_size(_size) {
resize(_size);
}
@ -22,7 +22,7 @@ esvg::render::Weight::~Weight() {
}
void esvg::render::Weight::resize(const ivec2& _size) {
void esvg::render::Weight::resize(const Vector2i& _size) {
m_size = _size;
float tmp(0);
m_data.resize(m_size.x()*m_size.y(), tmp);
@ -32,7 +32,7 @@ void esvg::render::Weight::resize(const ivec2& _size) {
}
}
const ivec2& esvg::render::Weight::getSize() const {
const Vector2i& esvg::render::Weight::getSize() const {
return m_size;
}
@ -50,7 +50,7 @@ void esvg::render::Weight::clear(float _fill) {
}
}
float esvg::render::Weight::get(const ivec2& _pos) const {
float esvg::render::Weight::get(const Vector2i& _pos) const {
if ( _pos.x()>=0 && _pos.x()<m_size.x()
&& _pos.y()>=0 && _pos.y()<m_size.y()) {
return m_data[_pos.x()+_pos.y()*m_size.x()];
@ -58,7 +58,7 @@ float esvg::render::Weight::get(const ivec2& _pos) const {
return 0;
}
void esvg::render::Weight::set(const ivec2& _pos, float _newColor) {
void esvg::render::Weight::set(const Vector2i& _pos, float _newColor) {
if ( _pos.x()>=0 && _pos.x()<m_size.x()
&& _pos.y()>=0 && _pos.y()<m_size.y()) {
m_data[_pos.x()+_pos.y()*m_size.x()] = _newColor;
@ -88,13 +88,13 @@ bool sortXPosFunction(const etk::Pair<float,int32_t>& _e1, const etk::Pair<float
}
void esvg::render::Weight::generate(ivec2 _size, int32_t _subSamplingCount, const esvg::render::SegmentList& _listSegment) {
void esvg::render::Weight::generate(Vector2i _size, int32_t _subSamplingCount, const esvg::render::SegmentList& _listSegment) {
resize(_size);
// for each lines:
for (int32_t yyy=0; yyy<_size.y(); ++yyy) {
Log.verbose("Weighting ... " << yyy << " / " << _size.y());
// Reduce the number of lines in the subsampling parsing:
etk::Vector<Segment> availlableSegmentPixel;
List<Segment> availlableSegmentPixel;
for (auto &it : _listSegment.m_data) {
if ( it.p0.y() < float(yyy+1)
&& it.p1.y() > float(yyy)) {
@ -112,7 +112,7 @@ void esvg::render::Weight::generate(ivec2 _size, int32_t _subSamplingCount, cons
Scanline scanline(_size.x());
//find all the segment that cross the middle of the line of the center of the pixel line:
float subSamplingCenterPos = yyy + deltaSize*0.5f + deltaSize*kkk;
etk::Vector<Segment> availlableSegment;
List<Segment> availlableSegment;
// find in the subList ...
for (auto &it : availlableSegmentPixel) {
if ( it.p0.y() <= subSamplingCenterPos
@ -135,9 +135,9 @@ void esvg::render::Weight::generate(ivec2 _size, int32_t _subSamplingCount, cons
Log.verbose(" Availlable Segment " << it.p0 << " -> " << it.p1 << " dir=" << it.direction);
}
// x position, angle
etk::Vector<etk::Pair<float, int32_t>> listPosition;
List<etk::Pair<float, int32_t>> listPosition;
for (auto &it : availlableSegment) {
vec2 delta = it.p0 - it.p1;
Vector2f delta = it.p0 - it.p1;
// x = coefficent*y+bbb;
float coefficient = delta.x()/delta.y();
float bbb = it.p0.x() - coefficient*it.p0.y();

16
src/org/atriasoft/esvg/render/Weight.java
View File

@ -14,28 +14,28 @@ namespace esvg {
namespace render {
class Weight {
private:
ivec2 m_size;
etk::Vector<float> m_data;
Vector2i m_size;
List<float> m_data;
public:
// constructor :
Weight();
Weight(const ivec2& _size);
Weight(const Vector2i& _size);
// destructor
~Weight();
// -----------------------------------------------
// -- basic tools :
// -----------------------------------------------
public:
void resize(const ivec2& _size);
const ivec2& getSize() const;
void resize(const Vector2i& _size);
const Vector2i& getSize() const;
int32_t getWidth() const;
int32_t getHeight() const;
void clear(float _fill);
float get(const ivec2& _pos) const;
void set(const ivec2& _pos, float _newColor);
float get(const Vector2i& _pos) const;
void set(const Vector2i& _pos, float _newColor);
void set(int32_t _posY, const esvg::render::Scanline& _data);
void append(int32_t _posY, const esvg::render::Scanline& _data);
void generate(ivec2 _size, int32_t _subSamplingCount, const esvg::render::SegmentList& _listSegment);
void generate(Vector2i _size, int32_t _subSamplingCount, const esvg::render::SegmentList& _listSegment);
};
}
}