Camera(Camera* camera, UInt32 alias_num)
{
if (alias_num >= camera.aliases.size())
ThrowCME("Camera: Internal error, alias number out of range specified.");
make = camera.make;
model = camera.aliases[alias_num];
canonical_make = camera.canonical_make;
canonical_model = camera.canonical_model;
canonical_alias = camera.canonical_aliases[alias_num];
canonical_id = camera.canonical_id;
mode = camera.mode;
cfa = camera.cfa;
supported = camera.supported;
cropSize = camera.cropSize;
cropPos = camera.cropPos;
decoderVersion = camera.decoderVersion;
for (UInt32 i = 0; i<camera.blackAreas.size(); i++) {
blackAreas.push_back(camera.blackAreas[i]);
}
for (UInt32 i = 0; i<camera.sensorInfo.size(); i++) {
sensorInfo.push_back(camera.sensorInfo[i]);
}
map<string, string>::const_iterator mi = camera.hints.begin();
for (; mi != camera.hints.end(); ++mi) {
hints.insert(make_pair((* mi).first, (* mi).second));
}
}
public static vector <case_t> read_test_cases()
{
vector <case_t> cases = new vector <case_t>();
uint8_t train_image = read_file("train-images.idx3-ubyte");
uint8_t train_labels = read_file("train-labels.idx1-ubyte");
uint32_t case_count = byteswap_uint32((uint32_t)(train_image + 4));
for (int i = 0; i < case_count; i++)
{
case_t c = new case_t(new tensor_t <float>(28, 28, 1), new tensor_t <float>(10, 1, 1));
uint8_t[] img = train_image + 16 + i * (28 * 28);
uint8_t label = train_labels + 8 + i;
for (int x = 0; x < 28; x++)
{
for (int y = 0; y < 28; y++)
{
c.data.functorMethod(x, y, 0) = img[x + y * 28] / 255.0f;
}
}
for (int b = 0; b < 10; b++)
{
[email protected](b, 0, 0) = label == b != 0 ? 1.0f : 0.0f;
}
cases.push_back(c);
}
train_image = null;
train_labels = null;
return(cases);
}
// Lay out a single bidi run
public void doLayoutRun(UInt16[] buf, int start, int count, int bufSize, bool isRtl, LayoutContext ctx, FontCollection collection)
{
hb_buffer_t buffer = LayoutEngine.getInstance().hbBuffer;
vector <FontCollection.Run> items = new vector <FontCollection.Run>();
collection.itemize(buf + start, count, ctx.style, items);
vector <hb_feature_t> features = new vector <hb_feature_t>();
// Disable default-on non-required ligature features if letter-spacing
// See http://dev.w3.org/csswg/css-text-3/#letter-spacing-property
// "When the effective spacing between two characters is not zero (due to
// either justification or a non-zero value of letter-spacing), user agents
// should not apply optional ligatures."
if (Math.Abs(ctx.paint.letterSpacing) > 0.03)
{
hb_feature_t no_liga = new hb_feature_t(HB_TAG('l', 'i', 'g', 'a'), 0, 0, ~0u);
hb_feature_t no_clig = new hb_feature_t(HB_TAG('c', 'l', 'i', 'g'), 0, 0, ~0u);
features.push_back(no_liga);
features.push_back(no_clig);
}
addFeatures(ctx.paint.fontFeatureSettings, features);
double size = ctx.paint.size;
double scaleX = ctx.paint.scaleX;
float x = mAdvance;
float y = 0F;
for (int run_ix = isRtl ? items.size() - 1 : 0; isRtl?run_ix >= 0 : run_ix < (int)items.size(); isRtl ?--run_ix :++run_ix)
{
FontCollection.Run run = items[run_ix];
if (run.fakedFont.font == null)
{
ALOGE("no font for run starting u+%04x length %d", buf[run.start], run.end - run.start);
continue;
}
int font_ix = findFace(run.fakedFont, ctx);
ctx.paint.font = mFaces[font_ix].font;
ctx.paint.fakery = mFaces[font_ix].fakery;
HarfBuzzSharp.Font hbFont = ctx.hbFonts[font_ix];
#if VERBOSE_DEBUG
ALOGD("Run %zu, font %d [%d:%d]", run_ix, font_ix, run.start, run.end);
#endif
hb_font_set_ppem(hbFont, size * scaleX, size);
hb_font_set_scale(hbFont, HBFloatToFixed(size * scaleX), HBFloatToFixed(size));
bool is_color_bitmap_font = isColorBitmapFont(hbFont);
// TODO: if there are multiple scripts within a font in an RTL run,
// we need to reorder those runs. This is unlikely with our current
// font stack, but should be done for correctness.
// Note: scriptRunStart and scriptRunEnd, as well as run.start and run.end,
// run between 0 and count.
uint scriptRunEnd;
for (uint scriptRunStart = run.start; scriptRunStart < run.end; scriptRunStart = scriptRunEnd)
{
scriptRunEnd = scriptRunStart;
hb_script_t script = getScriptRun(buf + start, run.end, ref scriptRunEnd);
// After the last line, scriptRunEnd is guaranteed to have increased,
// since the only time getScriptRun does not increase its iterator is when
// it has already reached the end of the buffer. But that can't happen,
// since if we have already reached the end of the buffer, we should have
// had (scriptRunEnd == run.end), which means (scriptRunStart == run.end)
// which is impossible due to the exit condition of the for loop. So we
// can be sure that scriptRunEnd > scriptRunStart.
double letterSpace = 0.0;
double letterSpaceHalfLeft = 0.0;
double letterSpaceHalfRight = 0.0;
if (ctx.paint.letterSpacing != 0.0 && isScriptOkForLetterspacing(new hb_script_t(script)))
{
letterSpace = ctx.paint.letterSpacing * size * scaleX;
if ((ctx.paint.paintFlags & LinearTextFlag) == 0)
{
letterSpace = Math.Round(letterSpace);
letterSpaceHalfLeft = Math.Floor(letterSpace * 0.5);
}
else
{
letterSpaceHalfLeft = letterSpace * 0.5;
}
letterSpaceHalfRight = letterSpace - letterSpaceHalfLeft;
}
hb_buffer_clear_contents(buffer);
hb_buffer_set_script(buffer, script);
hb_buffer_set_direction(buffer, isRtl ? HB_DIRECTION_RTL : HB_DIRECTION_LTR);
FontLanguages langList = FontLanguageListCache.getById(ctx.style.getLanguageListId());
if (langList.size() != 0)
{
FontLanguage hbLanguage = langList[0];
for (int i = 0; i < langList.size(); ++i)
{
if (langList[i].supportsHbScript(script))
{
hbLanguage = langList[i];
break;
}
}
hb_buffer_set_language(buffer, hbLanguage.getHbLanguage());
}
uint clusterStart = addToHbBuffer(buffer, new UInt16(buf), start, count, bufSize, scriptRunStart, scriptRunEnd, ctx.paint.hyphenEdit, hbFont);
hb_shape(hbFont, buffer, features.empty() ? null : features[0], features.size());
uint numGlyphs;
hb_glyph_info_t[] info = hb_buffer_get_glyph_infos(buffer, numGlyphs);
hb_glyph_position_t positions = hb_buffer_get_glyph_positions(buffer, null);
// At this point in the code, the cluster values in the info buffer
// correspond to the input characters with some shift. The cluster value
// clusterStart corresponds to the first character passed to HarfBuzz,
// which is at buf[start + scriptRunStart] whose advance needs to be saved
// into mAdvances[scriptRunStart]. So cluster values need to be reduced by
// (clusterStart - scriptRunStart) to get converted to indices of
// mAdvances.
uint clusterOffset = clusterStart - scriptRunStart;
if (numGlyphs != 0)
{
mAdvances[info[0].cluster - clusterOffset] += letterSpaceHalfLeft;
x += letterSpaceHalfLeft;
}
for (uint i = 0; i < numGlyphs; i++)
{
#if VERBOSE_DEBUG
ALOGD("%d %d %d %d", positions[i].x_advance, positions[i].y_advance, positions[i].x_offset, positions[i].y_offset);
ALOGD("DoLayout %u: %f; %d, %d", info[i].codepoint, HBFixedToFloat(positions[i].x_advance), positions[i].x_offset, positions[i].y_offset);
#endif
if (i > 0 && info[i - 1].cluster != info[i].cluster)
{
mAdvances[info[i - 1].cluster - clusterOffset] += letterSpaceHalfRight;
mAdvances[info[i].cluster - clusterOffset] += letterSpaceHalfLeft;
x += letterSpace;
}
hb_codepoint_t glyph_ix = info[i].codepoint;
float xoff = HBFixedToFloat(positions[i].x_offset);
float yoff = -HBFixedToFloat(positions[i].y_offset);
xoff += yoff * ctx.paint.skewX;
LayoutGlyph glyph = new LayoutGlyph(font_ix, glyph_ix, x + xoff, y + yoff, (uint)(info[i].cluster - clusterOffset));
mGlyphs.push_back(glyph);
float xAdvance = HBFixedToFloat(positions[i].x_advance);
if ((ctx.paint.paintFlags & LinearTextFlag) == 0)
{
xAdvance = roundf(xAdvance);
}
MinikinRect glyphBounds = new MinikinRect();
hb_glyph_extents_t extents = new hb_glyph_extents_t();
if (is_color_bitmap_font && hb_font_get_glyph_extents(hbFont, glyph_ix, extents))
{
// Note that it is technically possible for a TrueType font to have
// outline and embedded bitmap at the same time. We ignore modified
// bbox of hinted outline glyphs in that case.
glyphBounds.mLeft = roundf(HBFixedToFloat(extents.x_bearing));
glyphBounds.mTop = roundf(HBFixedToFloat(-extents.y_bearing));
glyphBounds.mRight = roundf(HBFixedToFloat(extents.x_bearing + extents.width));
glyphBounds.mBottom = roundf(HBFixedToFloat(-extents.y_bearing - extents.height));
}
else
{
ctx.paint.font.GetBounds(glyphBounds, glyph_ix, ctx.paint);
}
glyphBounds.offset(x + xoff, y + yoff);
mBounds.join(glyphBounds);
if ((int)(info[i].cluster - clusterOffset) < count)
{
mAdvances[info[i].cluster - clusterOffset] += xAdvance;
}
else
{
ALOGE("cluster %zu (start %zu) out of bounds of count %zu", info[i].cluster - clusterOffset, start, count);
}
x += xAdvance;
}
if (numGlyphs != 0)
{
mAdvances[info[numGlyphs - 1].cluster - clusterOffset] += letterSpaceHalfRight;
x += letterSpaceHalfRight;
}
}
}
mAdvance = x;
}
static int Main()
{
vector <case_t> cases = read_test_cases();
vector <layer_t> layers = new vector <layer_t>();
conv_layer_t layer1 = new conv_layer_t(1, 5, 8, cases[0].data.size); // 28 * 28 * 1 -> 24 * 24 * 8
//C++ TO C# CONVERTER TODO TASK: The following line was determined to contain a copy constructor call - this should be verified and a copy constructor should be created:
//ORIGINAL LINE: relu_layer_t * layer2 = new relu_layer_t(layer1->out.size);
relu_layer_t layer2 = new relu_layer_t(new point_t([email protected]));
//C++ TO C# CONVERTER TODO TASK: The following line was determined to contain a copy constructor call - this should be verified and a copy constructor should be created:
//ORIGINAL LINE: pool_layer_t * layer3 = new pool_layer_t(2, 2, layer2->out.size);
pool_layer_t layer3 = new pool_layer_t(2, 2, new point_t([email protected])); // 24 * 24 * 8 -> 12 * 12 * 8
//C++ TO C# CONVERTER TODO TASK: The following line was determined to contain a copy constructor call - this should be verified and a copy constructor should be created:
//ORIGINAL LINE: conv_layer_t * layer4 = new conv_layer_t(1, 3, 10, layer3->out.size);
conv_layer_t layer4 = new conv_layer_t(1, 3, 10, new point_t([email protected])); // 12 * 12 * 6 -> 10 * 10 * 10
//C++ TO C# CONVERTER TODO TASK: The following line was determined to contain a copy constructor call - this should be verified and a copy constructor should be created:
//ORIGINAL LINE: relu_layer_t * layer5 = new relu_layer_t(layer4->out.size);
relu_layer_t layer5 = new relu_layer_t(new point_t([email protected]));
//C++ TO C# CONVERTER TODO TASK: The following line was determined to contain a copy constructor call - this should be verified and a copy constructor should be created:
//ORIGINAL LINE: pool_layer_t * layer6 = new pool_layer_t(2, 2, layer5->out.size);
pool_layer_t layer6 = new pool_layer_t(2, 2, new point_t([email protected])); // 10 * 10 * 10 -> 5 * 5 * 10
//C++ TO C# CONVERTER TODO TASK: The following line was determined to contain a copy constructor call - this should be verified and a copy constructor should be created:
//ORIGINAL LINE: fc_layer_t * layer7 = new fc_layer_t(layer6->out.size, 10);
fc_layer_t layer7 = new fc_layer_t(new point_t([email protected]), 10); // 4 * 4 * 16 -> 10
layers.push_back((layer_t)layer1);
layers.push_back((layer_t)layer2);
layers.push_back((layer_t)layer3);
layers.push_back((layer_t)layer4);
layers.push_back((layer_t)layer5);
layers.push_back((layer_t)layer6);
layers.push_back((layer_t)layer7);
float amse = 0F;
int ic = 0;
for (int ep = 0; ep < 100000;)
{
foreach (case_t t in cases)
{
float xerr = train(layers, t.data.functorMethod, [email protected]);
amse += xerr;
ep++;
ic++;
if (ep % 1000 == 0)
{
Console.Write("case ");
Console.Write(ep);
Console.Write(" err=");
Console.Write(amse / ic);
Console.Write("\n");
}
// if ( GetAsyncKeyState( VK_F1 ) & 0x8000 )
// {
// printf( "err=%.4f%\n", amse / ic );
// goto end;
// }
}
}
// end:
while (true)
{
uint8_t[] data = read_file("test.ppm");
if (data != null)
{
//C++ TO C# CONVERTER TODO TASK: The following line was determined to contain a copy constructor call - this should be verified and a copy constructor should be created:
//ORIGINAL LINE: uint8_t * usable = data;
uint8_t[] usable = new uint8_t(data);
while ((uint32_t)usable != 0x0A353532)
{
usable++;
}
//C++ TO C# CONVERTER TODO TASK: There is no equivalent to most C++ 'pragma' directives in C#:
//#pragma pack(push, 1)
//C++ TO C# CONVERTER TODO TASK: C# does not allow declaring types within methods:
// struct RGB
// {
// uint8_t r, g, b;
// };
//C++ TO C# CONVERTER TODO TASK: There is no equivalent to most C++ 'pragma' directives in C#:
//#pragma pack(pop)
RGB[] rgb = (RGB)usable;
tensor_t <float> image = new tensor_t <float>(28, 28, 1);
for (int i = 0; i < 28; i++)
{
for (int j = 0; j < 28; j++)
{
RGB rgb_ij = rgb[i * 28 + j];
image.functorMethod(j, i, 0) = ((((float)rgb_ij.r + rgb_ij.g + rgb_ij.b) / (3.0f * 255.0f)));
}
}
forward(layers, image.functorMethod);
tensor_t <float> @out = layers.back().@out;
for (int i = 0; i < 10; i++)
{
Console.Write("[{0:D}] {1:f}\n", i, @out.functorMethod(i, 0, 0) * 100.0f);
}
data = null;
}
timespec wait = new timespec();
wait.tv_sec = 1;
wait.tv_nsec = 0;
nanosleep(wait, null);
}
return(0);
}
