682 lines
20 KiB
C++
682 lines
20 KiB
C++
|
||
|
||
#include "tunit.h"
|
||
#include "tconvert.h"
|
||
#include <math.h>
|
||
|
||
// Note: convertTo() means: convert from standard unit TO specific unit
|
||
// e.g. if unit=cm (standard=inch) then convertTo(1) == 2.54
|
||
//-------------------------------------------------------------------
|
||
|
||
/*
|
||
class VerticalCameraFldUnitConverter final : public TUnitConverter {
|
||
public:
|
||
static double m_factor;
|
||
VerticalCameraFldUnitConverter() {}
|
||
TUnitConverter * clone() const {return new
|
||
VerticalCameraFldUnitConverter(*this);}
|
||
double convertTo(double v) const {return v*m_factor;}
|
||
double convertFrom(double v) const {return v/m_factor;}
|
||
};
|
||
|
||
double VerticalCameraFldUnitConverter::m_factor = 1;
|
||
*/
|
||
|
||
namespace UnitParameters {
|
||
|
||
static std::pair<double, double> dummyCurrentDpiGetter() {
|
||
return std::make_pair<double, double>(72, 72);
|
||
}
|
||
|
||
CurrentDpiGetter currentDpiGetter = &dummyCurrentDpiGetter;
|
||
|
||
void setCurrentDpiGetter(CurrentDpiGetter f) { currentDpiGetter = f; }
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
class VerticalFldUnitConverter final : public TUnitConverter {
|
||
double m_factor;
|
||
|
||
public:
|
||
static double m_fieldGuideAspectRatio;
|
||
|
||
VerticalFldUnitConverter(double factor) : m_factor(factor) {}
|
||
TUnitConverter *clone() const override {
|
||
return new VerticalFldUnitConverter(*this);
|
||
}
|
||
double convertTo(double v) const override {
|
||
return v * m_fieldGuideAspectRatio * m_factor;
|
||
}
|
||
double convertFrom(double v) const override {
|
||
return v / (m_fieldGuideAspectRatio * m_factor);
|
||
}
|
||
};
|
||
double VerticalFldUnitConverter::m_fieldGuideAspectRatio = 1.38;
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
namespace UnitParameters {
|
||
|
||
void setFieldGuideAspectRatio(double ar) {
|
||
assert(ar > 0);
|
||
VerticalFldUnitConverter::m_fieldGuideAspectRatio = ar;
|
||
}
|
||
|
||
double getFieldGuideAspectRatio() {
|
||
return VerticalFldUnitConverter::m_fieldGuideAspectRatio;
|
||
}
|
||
}
|
||
|
||
//===================================================================
|
||
|
||
class TangentConverter final : public TUnitConverter {
|
||
public:
|
||
TangentConverter() {}
|
||
TUnitConverter *clone() const override { return new TangentConverter(*this); }
|
||
double convertTo(double v) const override {
|
||
return atan(v) * (M_1_PI * 180.0);
|
||
}
|
||
double convertFrom(double v) const override { return tan(v * M_PI_180); }
|
||
};
|
||
|
||
//===================================================================
|
||
|
||
class TPixelUnitXConverter final : public TUnitConverter {
|
||
public:
|
||
TPixelUnitXConverter() {}
|
||
TUnitConverter *clone() const override {
|
||
return new TPixelUnitXConverter(*this);
|
||
}
|
||
double convertTo(double v) const override {
|
||
return v * UnitParameters::currentDpiGetter().first;
|
||
}
|
||
double convertFrom(double v) const override {
|
||
return v / UnitParameters::currentDpiGetter().first;
|
||
}
|
||
};
|
||
|
||
class TPixelUnitYConverter final : public TUnitConverter {
|
||
public:
|
||
TPixelUnitYConverter() {}
|
||
TUnitConverter *clone() const override {
|
||
return new TPixelUnitYConverter(*this);
|
||
}
|
||
double convertTo(double v) const override {
|
||
return v * UnitParameters::currentDpiGetter().second;
|
||
}
|
||
double convertFrom(double v) const override {
|
||
return v / UnitParameters::currentDpiGetter().second;
|
||
}
|
||
};
|
||
|
||
//===================================================================
|
||
|
||
TUnit::TUnit(std::wstring ext, TUnitConverter *converter)
|
||
: m_defaultExtension(ext), m_converter(converter) {
|
||
m_extensions.push_back(ext);
|
||
if (m_converter == 0) m_converter = new TSimpleUnitConverter();
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
TUnit::TUnit(const TUnit &src)
|
||
: m_defaultExtension(src.m_defaultExtension)
|
||
, m_extensions(src.m_extensions)
|
||
, m_converter(src.m_converter->clone()) {}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
TUnit::~TUnit() { delete m_converter; }
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
void TUnit::addExtension(std::wstring ext) {
|
||
if (std::find(m_extensions.begin(), m_extensions.end(), ext) ==
|
||
m_extensions.end())
|
||
m_extensions.push_back(ext);
|
||
if (m_defaultExtension.empty()) m_defaultExtension = ext;
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
bool TUnit::isExtension(std::wstring ext) const {
|
||
return std::find(m_extensions.begin(), m_extensions.end(), ext) !=
|
||
m_extensions.end();
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
void TUnit::setDefaultExtension(std::wstring ext) {
|
||
if (!ext.empty() &&
|
||
std::find(m_extensions.begin(), m_extensions.end(), ext) ==
|
||
m_extensions.end())
|
||
m_extensions.push_back(ext);
|
||
m_defaultExtension = ext;
|
||
}
|
||
|
||
//===================================================================
|
||
|
||
TMeasure::TMeasure(std::string name, TUnit *mainUnit)
|
||
: m_name(name)
|
||
, m_mainUnit(0)
|
||
, m_standardUnit(0)
|
||
, m_currentUnit(0)
|
||
, m_defaultValue(0) {
|
||
add(mainUnit);
|
||
m_mainUnit = m_currentUnit = m_standardUnit = mainUnit;
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
TMeasure::TMeasure(const TMeasure &src)
|
||
: m_name(src.m_name)
|
||
, m_mainUnit(src.m_mainUnit)
|
||
, m_currentUnit(src.m_currentUnit)
|
||
, m_standardUnit(src.m_standardUnit)
|
||
, m_defaultValue(src.m_defaultValue) {
|
||
std::map<std::wstring, TUnit *>::const_iterator it;
|
||
for (it = src.m_extensions.begin(); it != src.m_extensions.end(); ++it) {
|
||
TUnit *u = it->second;
|
||
assert(u);
|
||
const std::vector<std::wstring> &e = u->getExtensions();
|
||
assert(std::find(e.begin(), e.end(), it->first) != e.end());
|
||
m_extensions[it->first] = u;
|
||
}
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
TMeasure::~TMeasure() {}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
void TMeasure::add(TUnit *unit) {
|
||
const std::vector<std::wstring> &e = unit->getExtensions();
|
||
for (int i = 0; i < (int)e.size(); i++) {
|
||
std::wstring ext = e[i];
|
||
assert(m_extensions.count(ext) == 0);
|
||
m_extensions[ext] = unit;
|
||
}
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
TUnit *TMeasure::getUnit(std::wstring ext) const {
|
||
std::map<std::wstring, TUnit *>::const_iterator it;
|
||
it = m_extensions.find(ext);
|
||
return it == m_extensions.end() ? 0 : it->second;
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
void TMeasure::setCurrentUnit(TUnit *unit) {
|
||
assert(unit);
|
||
assert(m_extensions.count(unit->getDefaultExtension()) > 0);
|
||
m_currentUnit = unit;
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
void TMeasure::setStandardUnit(TUnit *unit) {
|
||
assert(unit);
|
||
assert(m_extensions.count(unit->getDefaultExtension()) > 0);
|
||
m_standardUnit = unit;
|
||
}
|
||
|
||
//===================================================================
|
||
|
||
TMeasureManager::TMeasureManager() {
|
||
TUnit inch(L"in"), cm(L"cm", new TSimpleUnitConverter(2.54)),
|
||
mm(L"mm", new TSimpleUnitConverter(25.4)),
|
||
|
||
xfld(L"fld", new TSimpleUnitConverter(2)),
|
||
cameraXFld(L"fld", new TSimpleUnitConverter(1)),
|
||
|
||
yfld(L"fld", new VerticalFldUnitConverter(2)),
|
||
cameraYFld(L"fld", new VerticalFldUnitConverter(1)),
|
||
|
||
levelXFld(L"fld", new TSimpleUnitConverter(1)),
|
||
levelYFld(L"fld", new VerticalFldUnitConverter(1)),
|
||
|
||
internalZDepth(L"internal.zdepth"),
|
||
zdepth(L"zdepth", new TSimpleUnitConverter(1)), degree(L"\u00b0"),
|
||
scale(L"*"), percentage2(L"%"), shear(L"sh"),
|
||
shearAngle(L"\u00b0", new TangentConverter()),
|
||
percentage(L"%", new TSimpleUnitConverter(100)),
|
||
colorChannel(L"", new TSimpleUnitConverter(255)), dummy(L""),
|
||
xPixel(L"px", new TPixelUnitXConverter()),
|
||
yPixel(L"px", new TPixelUnitYConverter());
|
||
|
||
inch.addExtension(L"inch");
|
||
inch.addExtension(L"\"");
|
||
inch.addExtension(L"''");
|
||
inch.setDefaultExtension(L"\"");
|
||
|
||
xPixel.addExtension(L"pixel");
|
||
yPixel.addExtension(L"pixel");
|
||
|
||
xfld.addExtension(L"field");
|
||
cameraXFld.addExtension(L"field");
|
||
|
||
yfld.addExtension(L"field");
|
||
cameraYFld.addExtension(L"field");
|
||
|
||
levelXFld.addExtension(L"field");
|
||
levelYFld.addExtension(L"field");
|
||
|
||
xfld.addExtension(L"F");
|
||
yfld.addExtension(L"F");
|
||
cameraXFld.addExtension(L"F");
|
||
cameraYFld.addExtension(L"F");
|
||
|
||
levelXFld.addExtension(L"F");
|
||
levelYFld.addExtension(L"F");
|
||
|
||
TMeasure *length, *m;
|
||
|
||
length = m = new TMeasure("length", inch.clone());
|
||
m->add(cm.clone());
|
||
/*---
|
||
Fxの寸法パラメータは単位なし（実際にはStageInch（1 StageInch = 1/53.33333
|
||
inch）という値）
|
||
Fxの寸法パラメータからExpressionで単位のあるパラメータを参照すると、
|
||
カレントUnitによってFxの計算結果が変わってしまう。
|
||
tcomposerで用いられるカレントUnitはデフォルト値なので、
|
||
ここでデフォルトのカレントUnitをmmにしておくことで、
|
||
Unit = mm でシーンを作っておけば、作業時と同じRender結果が得られるようにする。
|
||
---*/
|
||
TUnit *mmUnit = mm.clone();
|
||
m->add(mmUnit);
|
||
m->setCurrentUnit(mmUnit);
|
||
add(m);
|
||
|
||
m = new TMeasure(*length);
|
||
m->setName("length.x");
|
||
m->add(xfld.clone());
|
||
m->add(xPixel.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure(*length);
|
||
m->setName("length.y");
|
||
m->add(yfld.clone());
|
||
m->add(yPixel.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure(*length);
|
||
m->setName("length.lx");
|
||
m->add(xfld.clone());
|
||
m->add(xPixel.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure(*length);
|
||
m->setName("length.ly");
|
||
m->add(yfld.clone());
|
||
m->add(yPixel.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure(*length);
|
||
m->setName("camera.lx");
|
||
m->add(cameraXFld.clone());
|
||
m->add(xPixel.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure(*length);
|
||
m->setName("camera.ly");
|
||
m->add(cameraYFld.clone());
|
||
m->add(yPixel.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure(*length);
|
||
m->setName("level.lx");
|
||
m->add(levelXFld.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure(*length);
|
||
m->setName("level.ly");
|
||
m->add(levelYFld.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure(*length);
|
||
m->setName("canvas.lx");
|
||
m->add(cameraXFld.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure(*length);
|
||
m->setName("canvas.ly");
|
||
m->add(cameraYFld.clone());
|
||
add(m);
|
||
|
||
const double stage_inch = 53.33333;
|
||
const double stage_standardDpi = 120;
|
||
|
||
TUnit fxLength(L"fxLength"),
|
||
fxInch(L"in", new TSimpleUnitConverter(1 / stage_inch)),
|
||
fxCm(L"cm", new TSimpleUnitConverter(2.54 / stage_inch)),
|
||
fxMm(L"mm", new TSimpleUnitConverter(25.4 / stage_inch)),
|
||
fxXfld(L"fld", new TSimpleUnitConverter(2 / stage_inch)),
|
||
fxPx(L"px", new TSimpleUnitConverter(stage_standardDpi / stage_inch));
|
||
fxInch.addExtension(L"inch");
|
||
fxInch.addExtension(L"\"");
|
||
fxInch.addExtension(L"''");
|
||
fxInch.setDefaultExtension(L"\"");
|
||
fxXfld.addExtension(L"field");
|
||
fxXfld.addExtension(L"F");
|
||
fxPx.addExtension(L"pixel");
|
||
m = new TMeasure("fxLength", fxLength.clone());
|
||
m->add(fxInch.clone());
|
||
m->add(fxCm.clone());
|
||
m->add(fxMm.clone());
|
||
m->add(fxXfld.clone());
|
||
m->add(fxPx.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure("angle", degree.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure("scale", scale.clone());
|
||
TUnit *unit = percentage.clone();
|
||
m->add(unit);
|
||
m->setCurrentUnit(unit);
|
||
m->setStandardUnit(unit);
|
||
add(m);
|
||
|
||
m = new TMeasure("percentage", scale.clone());
|
||
unit = percentage.clone();
|
||
m->add(unit);
|
||
m->setCurrentUnit(unit);
|
||
m->setStandardUnit(unit);
|
||
add(m);
|
||
|
||
m = new TMeasure("percentage2", percentage2.clone());
|
||
add(m);
|
||
|
||
m = new TMeasure("shear", shear.clone());
|
||
unit = shearAngle.clone();
|
||
m->add(unit);
|
||
m->setCurrentUnit(unit);
|
||
m->setStandardUnit(unit);
|
||
add(m);
|
||
|
||
m = new TMeasure("colorChannel", colorChannel.clone());
|
||
add(m);
|
||
|
||
/*
|
||
m = new TMeasure("zdepth", internalZDepth.clone());
|
||
unit = zdepth.clone();
|
||
m->add(unit);
|
||
m->setCurrentUnit(unit);
|
||
m->setStandardUnit(unit);
|
||
add(m);
|
||
*/
|
||
m = new TMeasure("dummy", dummy.clone());
|
||
add(m);
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
void TMeasureManager::add(TMeasure *m) { m_measures[m->getName()] = m; }
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
TMeasure *TMeasureManager::get(std::string name) const {
|
||
std::map<std::string, TMeasure *>::const_iterator it;
|
||
it = m_measures.find(name);
|
||
if (it == m_measures.end())
|
||
return 0;
|
||
else
|
||
return it->second;
|
||
}
|
||
|
||
//===================================================================
|
||
|
||
TMeasuredValue::TMeasuredValue(std::string measureName)
|
||
: m_measure(0), m_value(0) {
|
||
setMeasure(measureName);
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
TMeasuredValue::~TMeasuredValue() {}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
void TMeasuredValue::setMeasure(const TMeasure *measure) {
|
||
assert(measure);
|
||
if (!measure) return;
|
||
m_measure = measure;
|
||
m_value = m_measure->getDefaultValue();
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
void TMeasuredValue::setMeasure(std::string measureName) {
|
||
setMeasure(TMeasureManager::instance()->get(measureName));
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
bool TMeasuredValue::setValue(std::wstring s, int *pErr) {
|
||
if (s == L"" || s == L"-") {
|
||
if (pErr) *pErr = -1;
|
||
return false;
|
||
}
|
||
const TUnit *unit = m_measure->getCurrentUnit();
|
||
double value = 0;
|
||
bool valueFlag = false;
|
||
int i = 0, len = s.length();
|
||
// skip blanks
|
||
i = s.find_first_not_of(::to_wstring(" \t"));
|
||
assert(i != (int)std::wstring::npos);
|
||
int j = i;
|
||
// match number
|
||
if (i < len && (s[i] == L'-' || s[i] == L'+')) i++;
|
||
while (i < len && L'0' <= s[i] && s[i] <= L'9') i++;
|
||
if (i < len && s[i] == L'.') {
|
||
i++;
|
||
while (i < len && L'0' <= s[i] && s[i] <= L'9') i++;
|
||
if (i < len && (s[i] == L'E' || s[i] == L'e')) {
|
||
i++;
|
||
if (i < len && (s[i] == L'-' || s[i] == L'+')) i++;
|
||
while (i < len && L'0' <= s[i] && s[i] <= L'9') i++;
|
||
}
|
||
}
|
||
if (i > j) {
|
||
try {
|
||
value = std::stod(s.substr(j, i - j));
|
||
}
|
||
// handle exceptions
|
||
catch (const std::invalid_argument &e) {
|
||
return false;
|
||
} catch (const std::out_of_range &e) {
|
||
return false;
|
||
}
|
||
|
||
valueFlag = true;
|
||
// skip blanks
|
||
i = s.find_first_not_of(::to_wstring(" \t"), i);
|
||
if (i == (int)std::wstring::npos) i = s.length();
|
||
}
|
||
|
||
// remove trailing blanks
|
||
if (i < (int)s.length()) {
|
||
j = i;
|
||
i = s.find_last_not_of(::to_wstring(" \t"));
|
||
if (i == (int)std::wstring::npos) i = len - 1;
|
||
if (j <= i) {
|
||
std::wstring unitExt = s.substr(j, i + 1 - j);
|
||
unit = m_measure->getUnit(unitExt);
|
||
if (!unit) {
|
||
if (pErr) *pErr = -2;
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (valueFlag) {
|
||
double newValue = unit->convertFrom(value);
|
||
if (m_value == newValue) {
|
||
if (pErr) *pErr = 0;
|
||
return false;
|
||
}
|
||
m_value = newValue;
|
||
}
|
||
if (pErr) *pErr = (valueFlag || unit != 0) ? 0 : -3;
|
||
return valueFlag || unit != 0;
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
std::wstring TMeasuredValue::toWideString(int decimals) const {
|
||
double v = getValue(CurrentUnit);
|
||
std::string s = ::to_string(v, decimals);
|
||
if (s.find('.') != std::string::npos) {
|
||
int i = s.length();
|
||
while (i > 0 && s[i - 1] == '0') i--;
|
||
if (i > 0 && s[i - 1] == '.') i--;
|
||
if (i < (int)s.length()) s = s.substr(0, i);
|
||
}
|
||
std::wstring measure = m_measure->getCurrentUnit()->getDefaultExtension();
|
||
if (measure.empty()) return ::to_wstring(s);
|
||
return ::to_wstring(s) + L" " + measure;
|
||
}
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
void TMeasuredValue::modifyValue(double direction, int precision) {
|
||
for (int i = 0; i < precision; i++) {
|
||
direction /= 10;
|
||
}
|
||
std::wstring currExtension =
|
||
getMeasure()->getCurrentUnit()->getDefaultExtension();
|
||
// use a smaller value for inches and cm
|
||
if (currExtension == L"\"" || currExtension == L"cm") direction /= 10;
|
||
double v = getValue(CurrentUnit);
|
||
setValue(CurrentUnit, v + direction);
|
||
}
|
||
|
||
//===================================================================
|
||
|
||
namespace {
|
||
|
||
class ZDepthUnitConverter final : public TUnitConverter {
|
||
TMeasureManager::CameraSizeProvider *m_cameraSizeProvider;
|
||
|
||
public:
|
||
ZDepthUnitConverter(TMeasureManager::CameraSizeProvider *cameraSizeProvider)
|
||
: m_cameraSizeProvider(cameraSizeProvider) {}
|
||
TUnitConverter *clone() const override {
|
||
return new ZDepthUnitConverter(m_cameraSizeProvider);
|
||
}
|
||
inline double getCameraSize() const { return (*m_cameraSizeProvider)(); }
|
||
double convertTo(double v) const override {
|
||
return (1 - v * 0.001) * getCameraSize();
|
||
}
|
||
double convertFrom(double v) const override {
|
||
return (1 - v / getCameraSize()) * 1000.0;
|
||
}
|
||
};
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
class CameraZDepthUnitConverter final : public TUnitConverter {
|
||
TMeasureManager::CameraSizeProvider *m_cameraSizeProvider;
|
||
|
||
public:
|
||
CameraZDepthUnitConverter(
|
||
TMeasureManager::CameraSizeProvider *cameraSizeProvider)
|
||
: m_cameraSizeProvider(cameraSizeProvider) {}
|
||
TUnitConverter *clone() const override {
|
||
return new CameraZDepthUnitConverter(m_cameraSizeProvider);
|
||
}
|
||
inline double getCameraSize() const { return (*m_cameraSizeProvider)(); }
|
||
double convertTo(double v) const override {
|
||
return (1 + v * 0.001) * getCameraSize();
|
||
}
|
||
double convertFrom(double v) const override {
|
||
return (v / getCameraSize() - 1) * 1000.0;
|
||
}
|
||
};
|
||
|
||
//===================================================================
|
||
/*-- Zのカーブのハンドルの長さは0=0となるようにしなければならない --*/
|
||
class ZDepthHandleUnitConverter final : public TUnitConverter {
|
||
TMeasureManager::CameraSizeProvider *m_cameraSizeProvider;
|
||
|
||
public:
|
||
ZDepthHandleUnitConverter(
|
||
TMeasureManager::CameraSizeProvider *cameraSizeProvider)
|
||
: m_cameraSizeProvider(cameraSizeProvider) {}
|
||
|
||
TUnitConverter *clone() const override {
|
||
return new ZDepthHandleUnitConverter(m_cameraSizeProvider);
|
||
}
|
||
inline double getCameraSize() const { return (*m_cameraSizeProvider)(); }
|
||
double convertTo(double v) const override {
|
||
return -v * 0.001 * getCameraSize();
|
||
}
|
||
double convertFrom(double v) const override {
|
||
return (-v / getCameraSize()) * 1000.0;
|
||
}
|
||
};
|
||
|
||
class CameraZDepthHandleUnitConverter final : public TUnitConverter {
|
||
TMeasureManager::CameraSizeProvider *m_cameraSizeProvider;
|
||
|
||
public:
|
||
CameraZDepthHandleUnitConverter(
|
||
TMeasureManager::CameraSizeProvider *cameraSizeProvider)
|
||
: m_cameraSizeProvider(cameraSizeProvider) {}
|
||
|
||
TUnitConverter *clone() const override {
|
||
return new CameraZDepthHandleUnitConverter(m_cameraSizeProvider);
|
||
}
|
||
inline double getCameraSize() const { return (*m_cameraSizeProvider)(); }
|
||
double convertTo(double v) const override {
|
||
return v * 0.001 * getCameraSize();
|
||
}
|
||
double convertFrom(double v) const override {
|
||
return (v / getCameraSize()) * 1000.0;
|
||
}
|
||
};
|
||
|
||
} // namespace
|
||
|
||
//-------------------------------------------------------------------
|
||
|
||
void TMeasureManager::addCameraMeasures(
|
||
CameraSizeProvider *cameraSizeProvider) {
|
||
TUnit u0(L"z"), u1(L"fld", new ZDepthUnitConverter(cameraSizeProvider)),
|
||
u2(L"fld", new CameraZDepthUnitConverter(cameraSizeProvider)),
|
||
u3(L"fld", new ZDepthHandleUnitConverter(cameraSizeProvider)),
|
||
u4(L"fld", new CameraZDepthHandleUnitConverter(cameraSizeProvider));
|
||
|
||
TMeasure *zdepth = new TMeasure("zdepth", u0.clone());
|
||
TUnit *u = u1.clone();
|
||
zdepth->add(u);
|
||
zdepth->setCurrentUnit(u);
|
||
zdepth->setStandardUnit(u);
|
||
TMeasureManager::instance()->add(zdepth);
|
||
|
||
zdepth = new TMeasure("zdepth.cam", u0.clone());
|
||
u = u2.clone();
|
||
zdepth->add(u);
|
||
zdepth->setCurrentUnit(u);
|
||
zdepth->setStandardUnit(u);
|
||
|
||
TMeasureManager::instance()->add(zdepth);
|
||
|
||
zdepth = new TMeasure("zdepth.handle", u0.clone());
|
||
u = u3.clone();
|
||
zdepth->add(u);
|
||
zdepth->setCurrentUnit(u);
|
||
zdepth->setStandardUnit(u);
|
||
TMeasureManager::instance()->add(zdepth);
|
||
|
||
zdepth = new TMeasure("zdepth.cam.handle", u0.clone());
|
||
u = u4.clone();
|
||
zdepth->add(u);
|
||
zdepth->setCurrentUnit(u);
|
||
zdepth->setStandardUnit(u);
|
||
TMeasureManager::instance()->add(zdepth);
|
||
}
|