TEST(ConfusionMatrix, Init) {
ConfusionMatrix m;
const std::size_t kN = 10;
uint32_t golds_arr[kN] = {0, 0, 0, 0, 1, 1, 1, 1, 2, 3};
uint32_t preds_arr[kN] = {0, 0, 1, 1, 0, 0, 1, 1, 2, 3};
Data<uint64_t> golds;
Data<uint64_t> preds;
ToData(golds_arr, kN, &golds);
EXPECT_FALSE(m.Init(golds, preds));
EXPECT_TRUE(m.Init(golds, golds));
EXPECT_EQ(kN, m.num_instances());
EXPECT_EQ(4U, m.num_classes());
EXPECT_DOUBLE_EQ(1.0, m.accuracy());
EXPECT_DOUBLE_EQ(1.0, m.precision());
EXPECT_DOUBLE_EQ(1.0, m.recall());
EXPECT_DOUBLE_EQ(1.0, m.f1());
ToData(preds_arr, kN, &preds);
EXPECT_TRUE(m.Init(golds, preds));
EXPECT_EQ(kN, m.num_instances());
EXPECT_EQ(4U, m.num_classes());
EXPECT_DOUBLE_EQ(0.6, m.accuracy());
EXPECT_DOUBLE_EQ(0.75, m.precision());
EXPECT_DOUBLE_EQ(0.75, m.recall());
EXPECT_DOUBLE_EQ(0.75, m.f1());
}
void
BasicThebesLayerBuffer::DrawTo(ThebesLayer* aLayer,
gfxContext* aTarget,
float aOpacity,
Layer* aMaskLayer)
{
aTarget->Save();
// If the entire buffer is valid, we can just draw the whole thing,
// no need to clip. But we'll still clip if clipping is cheap ---
// that might let us copy a smaller region of the buffer.
// Also clip to the visible region if we're told to.
if (!aLayer->GetValidRegion().Contains(BufferRect()) ||
(ToData(aLayer)->GetClipToVisibleRegion() &&
!aLayer->GetVisibleRegion().Contains(BufferRect())) ||
IsClippingCheap(aTarget, aLayer->GetEffectiveVisibleRegion())) {
// We don't want to draw invalid stuff, so we need to clip. Might as
// well clip to the smallest area possible --- the visible region.
// Bug 599189 if there is a non-integer-translation transform in aTarget,
// we might sample pixels outside GetEffectiveVisibleRegion(), which is wrong
// and may cause gray lines.
gfxUtils::ClipToRegionSnapped(aTarget, aLayer->GetEffectiveVisibleRegion());
}
// Pull out the mask surface and transform here, because the mask
// is internal to basic layers
gfxMatrix maskTransform;
if (nsRefPtr<gfxASurface> maskSurface =
GetMaskSurfaceAndTransform(aMaskLayer, &maskTransform)) {
DrawBufferWithRotation(aTarget, aOpacity, maskSurface, &maskTransform);
} else {
DrawBufferWithRotation(aTarget, aOpacity);
}
aTarget->Restore();
}
TEST(Csv, ReadCsv) {
LabeledData<RealVector, uint32_t> data;
EXPECT_EQ(0U, data.size());
EXPECT_FALSE(ReadCsv("null/null", &data));
ASSERT_TRUE(ReadCsv("testdata/data/cls.10.csv", &data, LAST_COLUMN));
const std::size_t kN = 10;
EXPECT_EQ(kN, data.size());
uint32_t expected_labels_arr[kN] = {0, 1, 0, 1, 0, 1, 0, 1, 0, 1};
Data<uint32_t> expected_labels;
ToData(expected_labels_arr, kN, &expected_labels);
EXPECT_EQ(expected_labels, data.labels());
EXPECT_EQ(2U, data.input(0).size());
EXPECT_DOUBLE_EQ(2.4114, data.input(0)(0));
EXPECT_DOUBLE_EQ(-3.8901, data.input(0)(1));
ASSERT_TRUE(ReadCsv("testdata/data/cls.csv", &data));
EXPECT_EQ(1000U, data.size());
LabeledData<RealVector, double> data2;
ASSERT_TRUE(ReadCsv("testdata/data/cls.10.csv", &data2, FIRST_COLUMN));
EXPECT_EQ(10U, data2.size());
EXPECT_DOUBLE_EQ(2.4114, data2.label(0));
EXPECT_EQ(2U, data2.input(0).size());
EXPECT_DOUBLE_EQ(-3.8901, data2.input(0)(0));
EXPECT_DOUBLE_EQ(0, data2.input(0)(1));
}
void
BasicContainerLayer::Validate(LayerManager::DrawPaintedLayerCallback aCallback,
void* aCallbackData,
ReadbackProcessor* aReadback)
{
ReadbackProcessor readback;
if (BasicManager()->IsRetained()) {
readback.BuildUpdates(this);
}
for (Layer* l = mFirstChild; l; l = l->GetNextSibling()) {
BasicImplData* data = ToData(l);
data->Validate(aCallback, aCallbackData, &readback);
if (l->GetMaskLayer()) {
data = ToData(l->GetMaskLayer());
data->Validate(aCallback, aCallbackData, nullptr);
}
}
}
void
RotatedContentBuffer::DrawTo(ThebesLayer* aLayer,
gfxContext* aTarget,
float aOpacity,
gfxASurface* aMask,
const gfxMatrix* aMaskTransform)
{
if (!EnsureBuffer()) {
return;
}
RefPtr<DrawTarget> dt = aTarget->GetDrawTarget();
MOZ_ASSERT(dt, "Did you pass a non-Azure gfxContext?");
bool clipped = false;
// If the entire buffer is valid, we can just draw the whole thing,
// no need to clip. But we'll still clip if clipping is cheap ---
// that might let us copy a smaller region of the buffer.
// Also clip to the visible region if we're told to.
if (!aLayer->GetValidRegion().Contains(BufferRect()) ||
(ToData(aLayer)->GetClipToVisibleRegion() &&
!aLayer->GetVisibleRegion().Contains(BufferRect())) ||
IsClippingCheap(aTarget, aLayer->GetEffectiveVisibleRegion())) {
// We don't want to draw invalid stuff, so we need to clip. Might as
// well clip to the smallest area possible --- the visible region.
// Bug 599189 if there is a non-integer-translation transform in aTarget,
// we might sample pixels outside GetEffectiveVisibleRegion(), which is wrong
// and may cause gray lines.
gfxUtils::ClipToRegionSnapped(dt, aLayer->GetEffectiveVisibleRegion());
clipped = true;
}
RefPtr<gfx::SourceSurface> mask;
if (aMask) {
mask = gfxPlatform::GetPlatform()->GetSourceSurfaceForSurface(dt, aMask);
}
Matrix maskTransform;
if (aMaskTransform) {
maskTransform = ToMatrix(*aMaskTransform);
}
CompositionOp op = CompositionOpForOp(aTarget->CurrentOperator());
DrawBufferWithRotation(dt, BUFFER_BLACK, aOpacity, op, mask, &maskTransform);
if (clipped) {
dt->PopClip();
}
}
bool
BasicContainerLayer::ChildrenPartitionVisibleRegion(const gfx::IntRect& aInRect)
{
Matrix transform;
if (!GetEffectiveTransform().CanDraw2D(&transform) ||
ThebesMatrix(transform).HasNonIntegerTranslation())
return false;
nsIntPoint offset(int32_t(transform._31), int32_t(transform._32));
gfx::IntRect rect = aInRect.Intersect(GetEffectiveVisibleRegion().GetBounds() + offset);
nsIntRegion covered;
for (Layer* l = mFirstChild; l; l = l->GetNextSibling()) {
if (ToData(l)->IsHidden())
continue;
Matrix childTransform;
if (!l->GetEffectiveTransform().CanDraw2D(&childTransform) ||
ThebesMatrix(childTransform).HasNonIntegerTranslation() ||
l->GetEffectiveOpacity() != 1.0)
return false;
nsIntRegion childRegion = l->GetEffectiveVisibleRegion();
childRegion.MoveBy(int32_t(childTransform._31), int32_t(childTransform._32));
childRegion.And(childRegion, rect);
if (l->GetClipRect()) {
childRegion.And(childRegion, ParentLayerIntRect::ToUntyped(*l->GetClipRect()) + offset);
}
nsIntRegion intersection;
intersection.And(covered, childRegion);
if (!intersection.IsEmpty())
return false;
covered.Or(covered, childRegion);
}
return covered.Contains(rect);
}
sk_data_t* sk_data_new_subset(const sk_data_t* csrc, size_t offset, size_t length) {
return ToData(SkData::NewSubset(AsData(csrc), offset, length));
}
sk_data_t* sk_data_new_from_malloc(const void* memory, size_t length) {
return ToData(SkData::NewFromMalloc(memory, length));
}
sk_data_t* sk_data_new_with_copy(const void* src, size_t length) {
return ToData(SkData::NewWithCopy(src, length));
}
sk_data_t* sk_image_encode(const sk_image_t* cimage) {
return ToData(AsImage(cimage)->encode());
}
sk_data_t* sk_data_new_subset(const sk_data_t* csrc, size_t offset, size_t length) {
return ToData(SkData::MakeSubset(AsData(csrc), offset, length).release());
}
sk_data_t* sk_data_new_from_malloc(const void* memory, size_t length) {
return ToData(SkData::MakeFromMalloc(memory, length).release());
}
sk_data_t* sk_data_new_with_copy(const void* src, size_t length) {
return ToData(SkData::MakeWithCopy(src, length).release());
}
