67bffa1e278c15287bbf0b762f7e8dfe136c0c8e
1 #define INKSCAPE_LPE_RULER_CPP
3 /** \file
4 * LPE <ruler> implementation, see lpe-ruler.cpp.
5 */
7 /*
8 * Authors:
9 * Maximilian Albert
10 *
11 * Copyright (C) Maximilian Albert 2008 <maximilian.albert@gmail.com>
12 *
13 * Released under GNU GPL, read the file 'COPYING' for more information
14 */
16 #include "live_effects/lpe-ruler.h"
17 #include <2geom/piecewise.h>
18 #include <2geom/sbasis-geometric.h>
19 #include "inkscape.h"
20 #include "desktop.h"
23 namespace Inkscape {
24 namespace LivePathEffect {
26 static const Util::EnumData<MarkDirType> MarkDirData[] = {
27 {MARKDIR_LEFT , N_("Left"), "left"},
28 {MARKDIR_RIGHT , N_("Right"), "right"},
29 {MARKDIR_BOTH , N_("Both"), "both"},
30 };
31 static const Util::EnumDataConverter<MarkDirType> MarkDirTypeConverter(MarkDirData, sizeof(MarkDirData)/sizeof(*MarkDirData));
33 static const Util::EnumData<BorderMarkType> BorderMarkData[] = {
34 {BORDERMARK_NONE , N_("None"), "none"},
35 {BORDERMARK_START , N_("Start"), "start"},
36 {BORDERMARK_END , N_("End"), "end"},
37 {BORDERMARK_BOTH , N_("Both"), "both"},
38 };
39 static const Util::EnumDataConverter<BorderMarkType> BorderMarkTypeConverter(BorderMarkData, sizeof(BorderMarkData)/sizeof(*BorderMarkData));
41 LPERuler::LPERuler(LivePathEffectObject *lpeobject) :
42 Effect(lpeobject),
43 unit(_("Unit"), _("Unit"), "unit", &wr, this),
44 mark_distance(_("Mark distance"), _("Distance between successive ruler marks"), "mark_distance", &wr, this, 20.0),
45 mark_length(_("Major length"), _("Length of major ruler marks"), "mark_length", &wr, this, 14.0),
46 minor_mark_length(_("Minor length"), _("Length of minor ruler marks"), "minor_mark_length", &wr, this, 7.0),
47 major_mark_steps(_("Major steps"), _("Draw a major mark every ... steps"), "major_mark_steps", &wr, this, 5),
48 shift(_("Shift marks by"), _("Shift marks by this many steps"), "shift", &wr, this, 0),
49 mark_dir(_("Mark direction"), _("Direction of marks (when viewing along the path from start to end)"), "mark_dir", MarkDirTypeConverter, &wr, this, MARKDIR_LEFT),
50 offset(_("Offset"), _("Offset of first mark"), "offset", &wr, this, 0.0),
51 border_marks(_("Border marks"), _("Choose whether to draw marks at the beginning and end of the path"), "border_marks", BorderMarkTypeConverter, &wr, this, BORDERMARK_BOTH)
52 {
53 registerParameter(dynamic_cast<Parameter *>(&unit));
54 registerParameter(dynamic_cast<Parameter *>(&mark_distance));
55 registerParameter(dynamic_cast<Parameter *>(&mark_length));
56 registerParameter(dynamic_cast<Parameter *>(&minor_mark_length));
57 registerParameter(dynamic_cast<Parameter *>(&major_mark_steps));
58 registerParameter(dynamic_cast<Parameter *>(&shift));
59 registerParameter(dynamic_cast<Parameter *>(&offset));
60 registerParameter(dynamic_cast<Parameter *>(&mark_dir));
61 registerParameter(dynamic_cast<Parameter *>(&border_marks));
63 major_mark_steps.param_make_integer();
64 major_mark_steps.param_set_range(1, 1000);
65 shift.param_make_integer();
67 mark_length.param_set_increments(1.0, 10.0);
68 minor_mark_length.param_set_increments(1.0, 10.0);
69 offset.param_set_increments(1.0, 10.0);
70 }
72 LPERuler::~LPERuler()
73 {
75 }
77 Geom::Point LPERuler::n_major;
78 Geom::Point LPERuler::n_minor;
80 Geom::Piecewise<Geom::D2<Geom::SBasis> >
81 LPERuler::ruler_mark(Geom::Point const &A, Geom::Point const &n, MarkType const &marktype)
82 {
83 using namespace Geom;
85 gboolean success;
86 double real_mark_length = mark_length;
87 success = sp_convert_distance(&real_mark_length, unit, &sp_unit_get_by_id(SP_UNIT_PX));
88 double real_minor_mark_length = minor_mark_length;
89 success = sp_convert_distance(&real_minor_mark_length, unit, &sp_unit_get_by_id(SP_UNIT_PX));
91 n_major = real_mark_length * n;
92 n_minor = real_minor_mark_length * n;
94 Point C, D;
95 switch (marktype) {
96 case MARK_MAJOR:
97 C = A;
98 D = A + n_major;
99 if (mark_dir == MARKDIR_BOTH)
100 C -= n_major;
101 break;
102 case MARK_MINOR:
103 C = A;
104 D = A + n_minor;
105 if (mark_dir == MARKDIR_BOTH)
106 C -= n_minor;
107 break;
108 default:
109 // do nothing
110 break;
111 }
113 Piecewise<D2<SBasis> > seg(D2<SBasis>(Linear(C[X], D[X]), Linear(C[Y], D[Y])));
114 return seg;
115 }
117 Geom::Piecewise<Geom::D2<Geom::SBasis> >
118 LPERuler::doEffect_pwd2 (Geom::Piecewise<Geom::D2<Geom::SBasis> > const & pwd2_in)
119 {
120 using namespace Geom;
122 const int mminterval = static_cast<int>(major_mark_steps);
123 const int i_shift = static_cast<int>(shift) % mminterval;
124 int sign = (mark_dir == MARKDIR_RIGHT ? 1 : -1 );
126 Piecewise<D2<SBasis> >output(pwd2_in);
127 Piecewise<D2<SBasis> >speed = derivative(pwd2_in);
128 Piecewise<SBasis> arclength = arcLengthSb(pwd2_in);
129 double totlength = arclength.lastValue();
131 //find at which times to draw a mark:
132 std::vector<double> s_cuts;
134 double real_mark_distance = mark_distance;
135 gboolean success = sp_convert_distance(&real_mark_distance, unit, &sp_unit_get_by_id(SP_UNIT_PX));
137 double real_offset = offset;
138 success = sp_convert_distance(&real_offset, unit, &sp_unit_get_by_id(SP_UNIT_PX));
139 for (double s = real_offset; s<totlength; s+=real_mark_distance){
140 s_cuts.push_back(s);
141 }
142 std::vector<std::vector<double> > roots = multi_roots(arclength, s_cuts);
143 std::vector<double> t_cuts;
144 for (unsigned v=0; v<roots.size();v++){
145 //FIXME: 2geom multi_roots solver seem to sometimes "repeat" solutions.
146 //Here, we are supposed to have one and only one solution for each s.
147 if(roots[v].size()>0)
148 t_cuts.push_back(roots[v][0]);
149 }
150 //draw the marks
151 for (unsigned i=0; i<t_cuts.size(); i++){
152 Point A = pwd2_in(t_cuts[i]);
153 Point n = rot90(unit_vector(speed(t_cuts[i])))*sign;
154 if ((i % mminterval) == i_shift) {
155 output.concat (ruler_mark(A, n, MARK_MAJOR));
156 } else {
157 output.concat (ruler_mark(A, n, MARK_MINOR));
158 }
159 }
160 //eventually draw a mark at start
161 if ((border_marks == BORDERMARK_START || border_marks == BORDERMARK_BOTH) && (offset != 0.0 || i_shift != 0)){
162 Point A = pwd2_in.firstValue();
163 Point n = rot90(unit_vector(speed.firstValue()))*sign;
164 output.concat (ruler_mark(A, n, MARK_MAJOR));
165 }
166 //eventually draw a mark at end
167 if (border_marks == BORDERMARK_END || border_marks == BORDERMARK_BOTH){
168 Point A = pwd2_in.lastValue();
169 Point n = rot90(unit_vector(speed.lastValue()))*sign;
170 //speed.lastValue() is somtimes wrong when the path is closed: a tiny line seg might added at the end to fix rounding errors...
171 //TODO: Find a better fix!! (How do we know if the path was closed?)
172 if ( A == pwd2_in.firstValue() &&
173 speed.segs.size() > 1 &&
174 speed.segs.back()[X].size() <= 1 &&
175 speed.segs.back()[Y].size() <= 1 &&
176 speed.segs.back()[X].tailError(0) <= 1e-10 &&
177 speed.segs.back()[Y].tailError(0) <= 1e-10
178 ){
179 n = rot90(unit_vector(speed.segs[speed.segs.size()-2].at1()))*sign;
180 }
181 output.concat (ruler_mark(A, n, MARK_MAJOR));
182 }
184 return output;
185 }
187 } //namespace LivePathEffect
188 } /* namespace Inkscape */
190 /*
191 Local Variables:
192 mode:c++
193 c-file-style:"stroustrup"
194 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
195 indent-tabs-mode:nil
196 fill-column:99
197 End:
198 */
199 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :