int BodyParts::deserialise(LoadingState *state, data::IData *data)
{
base::Handle<data::Table> dataMap(data::Table::checkDataType(data, "body parts"));
if (!dataMap)
{
return 0;
}
for (auto iter = dataMap->beginArray(); iter != dataMap->endArray(); ++iter)
{
BodyPart *part = BodyPart::fromDeserialise(state, iter->get());
if (!part)
{
continue;
}
mPartList.push_back(part);
}
base::Handle<data::Number> num(dataMap->at<data::Number>("attackIndex"));
if (num)
{
mAttackIndex = num->integer();
}
return 1;
}
void Inventory::deserialise(LoadingState *state, data::IData *data)
{
Handle<data::Table> dataMap(dynamic_cast<data::Table *>(data));
if (!dataMap)
{
stringstream ss;
ss << "Unable to load inventory from a '" << data->typeName();
ss << "', must be a Map.";
am_log("LOADERR", ss);
return;
}
removeAll();
unsigned short width = mSpacesX;
unsigned short height = mSpacesY;
Handle<data::Number> num(dataMap->at<data::Number>("spacesX"));
if (num)
{
width = num->value<unsigned short>();
}
num = dataMap->at<data::Number>("spacesY");
if (num)
{
height = num->value<unsigned short>();
}
if (width != mSpacesX || height != mSpacesY)
{
if (width > 0 && height > 0)
{
setSpaces(width, height);
}
else
{
stringstream ss;
ss << "An inventory with space " << width << " x " << height;
ss << " is invalid";
am_log("LOADERR", ss);
}
}
Handle<data::Table> arr(dataMap->at<data::Table>("spots"));
if (arr)
{
for (auto iter = arr->beginArray(); iter != arr->endArray(); ++iter)
{
InventorySpot spot;
spot.deserialise(state, iter->get());
if (!addItem(spot.mItem, spot.mX, spot.mY))
{
stringstream ss;
ss << "Error adding item to inventory at " << spot.mX;
ss << " x " << spot.mY;
am_log("LOADERR", ss);
}
}
}
}
void StatModifiers::deserialise(LoadingState *state, data::IData *data)
{
Handle<data::Table> dataMap(data::Table::checkDataType(data, "stat modifiers"));
if (!dataMap)
{
return;
}
for (auto iter = dataMap->beginMap(); iter != dataMap->endMap(); ++iter)
{
Stat::StatType type = Stat::getStatType(iter->first.c_str());
if (type == Stat::MAX_STAT_LENGTH)
{
stringstream ss;
ss << "Unknown stat type '" << iter->first << "', unable to load stat modifiers.";
am_log("LOADERR", ss);
continue;
}
Handle<data::Table> arr(data::Table::checkDataType(iter->second.get(), "stat modifiers"));
if (arr)
{
continue;
}
for (auto modIter = arr->beginArray(); modIter != arr->endArray(); ++iter)
{
StatModifier mod;
if (mod.deserialise(state, modIter->get()))
{
addStatModifier(type, mod);
}
}
}
}
void Sprite::deserialise(am::game::LoadingState *state, data::IData *data)
{
Handle<data::Table> dataMap(dynamic_cast<data::Table *>(data));
if (!dataMap)
{
stringstream ss;
ss << "Unable to load sprite from '" << data->typeName();
}
Handle<data::String> str(dataMap->at<data::String>("asset"));
if (str)
{
setAsset(str->string());
}
Handle<data::Number> num(dataMap->at<data::Number>("width"));
if (num)
{
mWidth = num->value<float>();
}
num = dataMap->at<data::Number>("height");
if (num)
{
mHeight = num->value<float>();
}
num = dataMap->at<data::Number>("currentFrame");
if (num)
{
mCurrentFrame = num->valuei();
}
num = dataMap->at<data::Number>("frameRate");
if (num)
{
mFrameRate = num->value<float>();
}
num = dataMap->at<data::Number>("currentTime");
if (num)
{
mCurrentTime = num->value<float>();
}
str = dataMap->at<data::String>("scaleNineState");
if (str)
{
setScaleNineState(ScaleNine::getState(str->string()));
}
}
int BodyParts::deserialise(LoadingState *state, data::IData *data)
{
Handle<data::Table> dataMap(data::Table::checkDataType(data, "body parts"));
if (!dataMap)
{
return 0;
}
for (auto iter = dataMap->beginArray(); iter != dataMap->endArray(); ++iter)
{
BodyPart *part = BodyPart::fromDeserialise(state, iter->get());
if (!part)
{
continue;
}
mPartList.push_back(part);
}
}
void Stats::deserialise(LoadingState *state, data::IData *data)
{
base::Handle<data::Table> dataMap(data::Table::checkDataType(data, "stats"));
if (!dataMap)
{
return;
}
base::Handle<data::Table> baseStats(dataMap->at<data::Table>("baseStats"));
if (baseStats)
{
for (auto iter = baseStats->beginMap(); iter != baseStats->endMap(); ++iter)
{
Stat::StatType type = Stat::getStatType(iter->first.c_str());
if (type == Stat::MAX_STAT_LENGTH)
{
std::stringstream ss;
ss << "Unknown stat '" << iter->first << '\'';
am_log("LOADERR", ss);
continue;
}
base::Handle<data::Number> num(dynamic_cast<data::Number *>(iter->second.get()));
if (num)
{
setBaseStat(type, num->value<float>());
}
else
{
std::stringstream ss;
ss << "Cannot load base stat '" << iter->first << "' from a '";
ss << iter->second->typeName() << "'";
am_log("LOADERR", ss);
continue;
}
}
}
base::Handle<data::IData> tempData(dataMap->at("modifiers"));
if (tempData)
{
mModifiers->deserialise(state, tempData);
}
}
void ComputeMSURFDescriptor(
const ImageT & Lx ,
const ImageT & Ly ,
const int id_octave ,
const SIOPointFeature & ipt ,
Descriptor< Real , 64 > & desc )
{
Real dx = 0, dy = 0, mdx = 0, mdy = 0, gauss_s1 = 0, gauss_s2 = 0;
Real rx = 0, ry = 0, rrx = 0, rry = 0, xf = 0, yf = 0, ys = 0, xs = 0;
Real sample_x = 0, sample_y = 0, co = 0, si = 0, angle = 0;
Real ratio = 0;
int x1 = 0, y1 = 0, x2 = 0, y2 = 0, sample_step = 0, pattern_size = 0;
int kx = 0, ky = 0, i = 0, j = 0, dcount = 0;
int scale = 0, dsize = 0, level = 0;
// Subregion centers for the 4x4 gaussian weighting
Real cx = - static_cast<Real>( 0.5 ) , cy = static_cast<Real>( 0.5 ) ;
// Set the descriptor size and the sample and pattern sizes
dsize = 64;
sample_step = 5;
pattern_size = 12;
// Get the information from the keypoint
ratio = static_cast<Real>( 1 << id_octave );
scale = MathTrait<float>::round( ipt.scale() / ratio );
angle = ipt.orientation() ;
yf = ipt.y() / ratio;
xf = ipt.x() / ratio;
co = MathTrait<Real>::cos( angle );
si = MathTrait<Real>::sin( angle );
i = -8;
// Calculate descriptor for this interest point
// Area of size 24 s x 24 s
while ( i < pattern_size )
{
j = -8;
i = i - 4;
cx += 1.0;
cy = -0.5;
while ( j < pattern_size )
{
dx = dy = mdx = mdy = 0.0;
cy += 1.0;
j = j - 4;
ky = i + sample_step;
kx = j + sample_step;
xs = xf + ( -kx * scale * si + ky * scale * co );
ys = yf + ( kx * scale * co + ky * scale * si );
for ( int k = i; k < i + 9; ++k )
{
for ( int l = j; l < j + 9; ++l )
{
// Get coords of sample point on the rotated axis
sample_y = yf + ( l * scale * co + k * scale * si );
sample_x = xf + ( -l * scale * si + k * scale * co );
// Get the gaussian weighted x and y responses
gauss_s1 = gaussian( xs - sample_x, ys - sample_y, static_cast<Real>( 2.5 ) * static_cast<Real>( scale ) );
rx = SampleLinear( Lx, sample_y, sample_x );
ry = SampleLinear( Ly, sample_y, sample_x );
// Get the x and y derivatives on the rotated axis
rry = gauss_s1 * ( rx * co + ry * si );
rrx = gauss_s1 * ( -rx * si + ry * co );
// Sum the derivatives to the cumulative descriptor
dx += rrx;
dy += rry;
mdx += MathTrait<Real>::abs( rrx );
mdy += MathTrait<Real>::abs( rry );
}
}
// Add the values to the descriptor vector
gauss_s2 = gaussian( cx - static_cast<Real>( 2.0 ) , cy - static_cast<Real>( 2.0 ) , static_cast<Real>( 1.5 ) ) ;
desc[dcount++] = dx * gauss_s2;
desc[dcount++] = dy * gauss_s2;
desc[dcount++] = mdx * gauss_s2;
desc[dcount++] = mdy * gauss_s2;
j += 9;
}
i += 9;
}
// convert to unit vector (L2 norm)
typedef Eigen::Matrix<Real, Eigen::Dynamic, 1> VecReal;
Eigen::Map< VecReal > dataMap( &desc[0], 64);
dataMap.normalize();
//std::cout << dataMap.transpose() << std::endl << std::endl;
}
