rs_units.cpp

qcad2.05可用于windows和linux的源码

/****************************************************************************
** $Id: rs_units.cpp 1938 2004-12-09 23:09:53Z andrew $
**
** Copyright (C) 2001-2003 RibbonSoft. All rights reserved.
**
** This file is part of the qcadlib Library project.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid qcadlib Professional Edition licenses may use 
** this file in accordance with the qcadlib Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.ribbonsoft.com for further details.
**
** Contact [e-mail] if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/


#include "rs_units.h"

#include <stdio.h>
#include <qobject.h>

#include "rs_math.h"
#include "rs_debug.h"

/**
 * Converts a DXF integer () to a Unit enum.
 */
RS2::Unit RS_Units::dxfint2unit(int dxfint) {
    return (RS2::Unit)dxfint;

    /*switch(dxfint) {
    default:
    case  0:
        return RS2::None;
    case  1:
        return RS2::Inch;
    case  2:
        return RS2::Foot;
    case  3:
        return RS2::Mile;
    case  4:
        return RS2::Millimeter;
    case  5:
        return RS2::Centimeter;
    case  6:
        return RS2::Meter;
    case  7:
        return RS2::Kilometer;
    case  8:
        return RS2::Microinch;
    case  9:
        return RS2::Mil;
    case 10:
        return RS2::Yard;
    case 11:
        return RS2::Angstrom;
    case 12:
        return RS2::Nanometer;
    case 13:
        return RS2::Micron;
    case 14:
        return RS2::Decimeter;
    case 15:
        return RS2::Decameter;
    case 16:
        return RS2::Hectometer;
    case 17:
        return RS2::Gigameter;
    case 18:
        return RS2::Astro;
    case 19:
        return RS2::Lightyear;
    case 20:
        return RS2::Parsec;
}*/
}


/**
 * @return a short string representing the given unit (e.g. "mm")
 */
RS_String RS_Units::unitToSign(RS2::Unit u) {
    RS_String ret = "";

    switch (u) {
    case RS2::None:
        ret = "";
        break;
    case RS2::Inch:
        ret = "\"";
        break;
    case RS2::Foot:
        ret = "'";
        break;
    case RS2::Mile:
        ret = "mi";
        break;
    case RS2::Millimeter:
        ret = "mm";
        break;
    case RS2::Centimeter:
        ret = "cm";
        break;
    case RS2::Meter:
        ret = "m";
        break;
    case RS2::Kilometer:
        ret = "km";
        break;
    case RS2::Microinch:
        ret = "礬"";
        break;
    case RS2::Mil:
        ret = "mil";
        break;
    case RS2::Yard:
        ret = "yd";
        break;
    case RS2::Angstrom:
        ret = "A";
        break;
    case RS2::Nanometer:
        ret = "nm";
        break;
    case RS2::Micron:
        ret = "祄";
        break;
    case RS2::Decimeter:
        ret = "dm";
        break;
    case RS2::Decameter:
        ret = "dam";
        break;
    case RS2::Hectometer:
        ret = "hm";
        break;
    case RS2::Gigameter:
        ret = "Gm";
        break;
    case RS2::Astro:
        ret = "astro";
        break;
    case RS2::Lightyear:
        ret = "ly";
        break;
    case RS2::Parsec:
        ret = "pc";
        break;

    default:
        ret = "";
        break;
    }

    return ret;
}



/**
 * @return a string representing the given unit (e.g. "Millimeter").
 *      translated if @a t is true (the default).
 */
RS_String RS_Units::unitToString(RS2::Unit u, bool t) {
    RS_String ret = "";

    switch (u) {
    case RS2::None:
        ret = t ? QObject::tr("None") : RS_String("None");
        break;
    case RS2::Inch:
        ret = t ? QObject::tr("Inch") : RS_String("Inch");
        break;
    case RS2::Foot:
        ret = t ? QObject::tr("Foot") : RS_String("Foot");
        break;
    case RS2::Mile:
        ret = t ? QObject::tr("Mile") : RS_String("Mile");
        break;
    case RS2::Millimeter:
        ret = t ? QObject::tr("Millimeter") : RS_String("Millimeter");
        break;
    case RS2::Centimeter:
        ret = t ? QObject::tr("Centimeter") : RS_String("Centimeter");
        break;
    case RS2::Meter:
        ret = t ? QObject::tr("Meter") : RS_String("Meter");
        break;
    case RS2::Kilometer:
        ret = t ? QObject::tr("Kilometer") : RS_String("Kilometer");
        break;
    case RS2::Microinch:
        ret = t ? QObject::tr("Microinch") : RS_String("Microinch");
        break;
    case RS2::Mil:
        ret = t ? QObject::tr("Mil") : RS_String("Mil");
        break;
    case RS2::Yard:
        ret = t ? QObject::tr("Yard") : RS_String("Yard");
        break;
    case RS2::Angstrom:
        ret = t ? QObject::tr("Angstrom") : RS_String("Angstrom");
        break;
    case RS2::Nanometer:
        ret = t ? QObject::tr("Nanometer") : RS_String("Nanometer");
        break;
    case RS2::Micron:
        ret = t ? QObject::tr("Micron") : RS_String("Micron");
        break;
    case RS2::Decimeter:
        ret = t ? QObject::tr("Decimeter") : RS_String("Decimeter");
        break;
    case RS2::Decameter:
        ret = t ? QObject::tr("Decameter") : RS_String("Decameter");
        break;
    case RS2::Hectometer:
        ret = t ? QObject::tr("Hectometer") : RS_String("Hectometer");
        break;
    case RS2::Gigameter:
        ret = t ? QObject::tr("Gigameter") : RS_String("Gigameter");
        break;
    case RS2::Astro:
        ret = t ? QObject::tr("Astro") : RS_String("Astro");
        break;
    case RS2::Lightyear:
        ret = t ? QObject::tr("Lightyear") : RS_String("Lightyear");
        break;
    case RS2::Parsec:
        ret = t ? QObject::tr("Parsec") : RS_String("Parsec");
        break;

    default:
        ret = "";
        break;
    }

    return ret;
}



/**
 * Converts a string into a unit enum.
 */
RS2::Unit RS_Units::stringToUnit(const RS_String& u) {
    RS2::Unit ret = RS2::None;

    if (u=="None") {
        ret = RS2::None;
    } else if (u==QObject::tr("Inch")) {
        ret = RS2::Inch;
    } else if (u==QObject::tr("Foot")) {
        ret = RS2::Foot;
    } else if (u==QObject::tr("Mile")) {
        ret = RS2::Mile;
    } else if (u==QObject::tr("Millimeter")) {
        ret = RS2::Millimeter;
    } else if (u==QObject::tr("Centimeter")) {
        ret = RS2::Centimeter;
    } else if (u==QObject::tr("Meter")) {
        ret = RS2::Meter;
    } else if (u==QObject::tr("Kilometer")) {
        ret = RS2::Kilometer;
    } else if (u==QObject::tr("Microinch")) {
        ret = RS2::Microinch;
    } else if (u==QObject::tr("Mil")) {
        ret = RS2::Mil;
    } else if (u==QObject::tr("Yard")) {
        ret = RS2::Yard;
    } else if (u==QObject::tr("Angstrom")) {
        ret = RS2::Angstrom;
    } else if (u==QObject::tr("Nanometer")) {
        ret = RS2::Nanometer;
    } else if (u==QObject::tr("Micron")) {
        ret = RS2::Micron;
    } else if (u==QObject::tr("Decimeter")) {
        ret = RS2::Decimeter;
    } else if (u==QObject::tr("Decameter")) {
        ret = RS2::Decameter;
    } else if (u==QObject::tr("Hectometer")) {
        ret = RS2::Hectometer;
    } else if (u==QObject::tr("Gigameter")) {
        ret = RS2::Gigameter;
    } else if (u==QObject::tr("Astro")) {
        ret = RS2::Astro;
    } else if (u==QObject::tr("Lightyear")) {
        ret = RS2::Lightyear;
    } else if (u==QObject::tr("Parsec")) {
        ret = RS2::Parsec;
    }

    return ret;
}




/**
 * @return true: the unit is metric, false: the unit is imperial.
 */
bool RS_Units::isMetric(RS2::Unit u) {
    if (u==RS2::Millimeter ||
            u==RS2::Centimeter ||
            u==RS2::Meter ||
            u==RS2::Kilometer ||
            u==RS2::Angstrom ||
            u==RS2::Nanometer ||
            u==RS2::Micron ||
            u==RS2::Decimeter ||
            u==RS2::Decameter ||
            u==RS2::Hectometer ||
            u==RS2::Gigameter ||
            u==RS2::Astro ||
            u==RS2::Lightyear ||
            u==RS2::Parsec) {

        return true;
    } else {
        return false;
    }
}



/**
 * @return factor to convert the given unit to Millimeters.
 */
double RS_Units::getFactorToMM(RS2::Unit u) {
    double ret = 1.0;

    switch (u) {
    case RS2::None:
        ret = 1.0;
        break;
    case RS2::Inch:
        ret = 25.4;
        break;
    case RS2::Foot:
        ret = 304.8;
        break;
    case RS2::Mile:
        ret = 1609344;
        break;
    case RS2::Millimeter:
        ret = 1.0;
        break;
    case RS2::Centimeter:
        ret = 10;
        break;
    case RS2::Meter:
        ret = 1000;
        break;
    case RS2::Kilometer:
        ret = 1000000;
        break;
    case RS2::Microinch:
        ret = 0.0000254;
        break;
    case RS2::Mil:
        ret = 0.0254;
        break;
    case RS2::Yard:
        ret = 914.4;
        break;
    case RS2::Angstrom:
        ret = 0.0000001;
        break;
    case RS2::Nanometer:
        ret = 0.000001;
        break;
    case RS2::Micron:
        ret = 0.001;
        break;
    case RS2::Decimeter:
        ret = 100.0;
        break;
    case RS2::Decameter:
        ret = 10000.0;
        break;
    case RS2::Hectometer:
        ret = 100000.0;
        break;
    case RS2::Gigameter:
        ret = 1000000000.0;
        break;
    case RS2::Astro:
        ret = 149600000000000.0;
        break;
    case RS2::Lightyear:
        ret = 9460731798000000000.0;
        break;
    case RS2::Parsec:
        ret = 30857000000000000000.0;
        break;
    default:
        ret = 1.0;
        break;
    }

    return ret;
}


/**
 * Converts the given value 'val' from unit 'src' to unit 'dest'.
 */
double RS_Units::convert(double val, RS2::Unit src, RS2::Unit dest) {
    if (getFactorToMM(dest)>0.0) {
        return (val*getFactorToMM(src))/getFactorToMM(dest);
    } else {
        RS_DEBUG->print(RS_Debug::D_WARNING,
			"RS_Units::convert: invalid factor");
        return val;
    }
}



/**
 * Converts the given vector 'val' from unit 'src' to unit 'dest'.
 */
RS_Vector RS_Units::convert(const RS_Vector val, RS2::Unit src, RS2::Unit dest) {
    return RS_Vector(convert(val.x, src, dest),
                     convert(val.y, src, dest),
                     convert(val.z, src, dest));
}



/**
 * Formats the given length in the given format.
 *
 * @param length The length in the current unit of the drawing.
 * @param format Format of the string.
 * @param prec Precisision of the value (e.g. 0.001 or 1/128 = 0.0078125)
 & @param showUnit Append unit to the value.
 */