display scale factor

classic Classic list List threaded Threaded
1 message Options
Reply | Threaded
Open this post in threaded view

display scale factor

Recently, I wanted to use Inkscape to draw a floor plan for a large
house. For this, I needed to use a grid specified in feet and inches.

I found that in order to fit the whole drawing on the screen at once, I
had to set the zoom factor to 3% or less, which was inconvenient. It
seems that for some reason you cannot set a zoom factor of less than 1%,
so if the building were even three times larger, there would be no way
to view it all at once, if you used the correct units to draw it.

It seems that I'm not the only person having this problem:


The suggested solution is to scale your drawing in "px" units, and then
apply a mental scale factor to get the real dimensions. Of course you
COULD do that, but why should you have to? Why can't Inkscape
accommodate whatever units, dimensions, and scales are appropriate for
the task at hand?

My first solution was as follows. The inch and foot units are defined in
the Inkscape config file "/usr/share/inkscape/ui/units.txt", or possibly
"/usr/share/inkscape/ui/units.xml". I'm not sure which of these files is
supposed to be normative; why are there two of them?

  # name    plural     abbr type     factor   PRI description

    inch    inches     in   LINEAR   90.0     N   Inches (90 px/in)
    foot    feet       ft   LINEAR   1080     N   Feet (12 in/ft)

I added the following units, which are defined to be 1/360 of the usual

    x-inch  x-inches   xin  LINEAR   0.25     N   X-Inches (0.25 px/xin)
    x-foot  x-feet     xft  LINEAR   3        N   X-Feet (12 xin/xft)

Inkscape then recognizes these new units for the "Default units" and
"Page Size" options, and for the "Transform" dialog. It DOES NOT
recognize them for the object dimension boxes along the top of the
canvas, and when the drawing's default unit is set to "xft", the rulers
are graduated in "px" units.

I then tried adding the same definitions to the "units.xml" file:

    <unit type="LINEAR" pri="n">
        <description>X-Inches (0.25 px/xin)</description>
    <unit type="LINEAR" pri="n">
        <description>X-Feet (12 xin/xft)</description>

This did not appear to have any further effect.

It seems rather silly that for some purposes, the unit definitions would
be read at runtime from a config file, while for other purposes, they
would be compiled into the program binary, but that appears to be how it
currently works.

I suppose I could fix this so that all the unit definitions were read
from a single config file at runtime, and then define corresponding
metric x-units as 1/100 of the usual ones, but that would be kind of
pointless. People who want to draw cells, or integrated circuits, or
molecules, would have to define y-micrometres, y-nanometres, and
y-angstroms, as a million times bigger than the standard units, because
it turns out that the maximum zoom factor you can apply is 25600%, or
256. (It's pretty silly to have to write 256 as "25600%", but apparently
you do have to.)

There is a much better solution, which is illustrated by the attached
image "scale.png". This is intended as an addition to the current
"Document Properties/Page" config window. It specifies the scale at
which the drawing will be displayed on the physical screen, as a ratio
between real dimensions on the screen, and the declared dimensions of
the drawing.

This does not replace the current "Zoom" option in the "View" menu or
the box in the lower right corner of the main window. It is simply
multiplied together with that setting, so if the zoom factor is set to
"1:1" or "100%", the specified display scale factor is what you get. The
intention is that the display scale factor will be set once, to an
appropriate value for the drawing, while the zoom factor will be changed
frequently while working.

The display scale factor is specified as a ratio between two values,
each of which consists of a decimal number and a unit chosen from a
selection list. The available units are those read from the
units.{txt,xml} file, with the addition of "width" and "height". These
two units will refer to the physical screen dimensions, and the declared
page size for the drawing. You can therefore specify that the normal
display scale is such that the width of the drawing is the width of the
screen (or half that, or twice that). This is likely to be useful,
because often the X server does not have an accurate idea of the
physical screen dimensions, but it always knows the size in pixels.

It seems that this feature should be fairly simple to implement, for
someone familiar with the Inkscape code. It only requires four
additional widgets for the Document Properties window, for this setting
to be saved and read from the SVG file, and for the resulting value to
be multiplied with the existing zoom factor wherever that appears.

Note the following related feature request, rated as "Priority: High":


    Bob wants to draw a house plan in feet and inches, but still print
    it on a letter-sized paper. (one idea: different layers can have
    different scales: e.g. border layer is actual size, house layer is 1
    in. = 8 ft.)

I would point out that the SVG specification does not prescribe any
particular ratio between "px" drawing units and actual physical lengths.
(It certainly DOES NOT specify that 90 px = 1 inch, as Inkscape
currently assumes [units.txt]; this ratio is only mentioned as "for


I suggest that for Inkscape, "px" be considered to be equivalent to the
specified "Default unit" from the Document Properties window. If the
default unit is metres, or whatever, then that's what "px" means, for
that document, but no other. I don't see how this is inconsistent with
the SVG specification.

Another related proposal is here:


>> I think that if we are going to break compatibility, we go for one
>> release to do it. Basically, all of the new-style stuff including
>> custom doc coords would be a huge win to introduce all at once. I
>> would love to see a rotatable canvas in Inkscape, but I have no idea
>> how feasible it is with the current rendering/viewport stuff we have
>> in place.
> In principle it should be possible to change doc2dt and dt2doc
> matrices to any transform without any modifications to the display
> subsystem, but it might expose bugs - mainly hidden assumptions that
> doc2dt is always an Y flip + translation.
If the canvas can be rotated by an arbitrary angle (or "any transform
matrix" applied), then certainly another uniform scaling factor can be
applied at the same time.

Finally, I must comment on how strange it is that "units.txt" contains
the following definition:

  # name    plural   abbr type           factor   PRI description

    %       %        %    DIMENSIONLESS  1.00     Y   Percentage

It seems clear that since 100% = 100/100 = 1.0 , then 1% = 1/100 = 0.01
; this is what the conversion factor should be.

Only slightly less strange is this:

    degree  degrees  deg  RADIAL         1.00     Y   Degrees

The natural base unit for rotations (if not radians) is one whole
rotation, the identity operation, analogous to multiplication by one.

These definitions necessarily imply that there must be inverse
conversion factors of "100" and "360" hard-wired into the Inkscape code
somewhere. But why should that be? The natural place for such conversion
factors is this same "units.txt" definition file; that's what it's FOR.

In this regard, it would be helpful if whatever piece of code is
responsible for reading these definitions were (trivially) extended to
handle ratios; then a degree could be defined as "1/360", rather than

Then, if someone wants to specify angles in milliradians, for some
reason, they can define that as "1/6283.185", rather than "0.05729578",
as is currently necessary.


Similarly, if someone is working on some tiling problem and wants to
scale things by multiples of 1/64, rather than 1/100, they can call that
a "perfoo", and define it as "1/64", instead of "1.5625", as currently

Another thing that would be useful for this file is to have some
notation for "the n-th root of x"; for example, "2\4" could mean "the
fourth root of two", which might otherwise be written as "2^(1/4)".

Currently, the "+" and "-" keys zoom the display by a factor of 2^(1/2)
(usually called "square root of two", 1.414214), while the up and down
arrows next to the zoom factor box change it by almost, but not quite,
2^(1/10) ("tenth root of two", 1.071773). If there were some convenient
notation for specifying geometric roots in the "units.txt" file, these
zoom factors might be made configurable, and they could also be used in
the "Transform" dialog for scaling objects.

-- Ian Bruce

LogMeIn Central: Instant, anywhere, Remote PC access and management.
Stay in control, update software, and manage PCs from one command center
Diagnose problems and improve visibility into emerging IT issues
Automate, monitor and manage. Do more in less time with Central
Inkscape-devel mailing list
[hidden email]

scale.png (36K) Download Attachment