bool QLearner::load_data(const char* filename)
{
FILE* file = NULL;
file = fopen(filename, "r");
if(!file)
{
return false;
}
int QListSize;
bool tmp = fscanf(file,"QList Data. x1,x2,action:qvalue\nElement Count: %d\n",&QListSize);
//QList.resize(0);
int tmpAction;
double tmpQValue;
State tmpState(0,0);
for(int i = 0; i < QListSize; i++)
{
tmp = fscanf(file,"%d,%d,%d:%lf\n",&tmpState.x1,&tmpState.x2,&tmpAction,&tmpQValue);
QList.push_back(QTable(StateAction(tmpState,static_cast<Action>(tmpAction)), tmpQValue));
}
return true;
}
already_AddRefed<gfxPattern>
nsSVGMaskFrame::ComputeMaskAlpha(nsSVGRenderState *aContext,
nsIFrame* aParent,
const gfxMatrix &aMatrix,
float aOpacity)
{
// If the flag is set when we get here, it means this mask frame
// has already been used painting the current mask, and the document
// has a mask reference loop.
if (mInUse) {
NS_WARNING("Mask loop detected!");
return nsnull;
}
AutoMaskReferencer maskRef(this);
nsSVGMaskElement *mask = static_cast<nsSVGMaskElement*>(mContent);
PRUint16 units =
mask->mEnumAttributes[nsSVGMaskElement::MASKUNITS].GetAnimValue();
gfxRect bbox;
if (units == nsIDOMSVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX) {
bbox = nsSVGUtils::GetBBox(aParent);
}
gfxRect maskArea = nsSVGUtils::GetRelativeRect(units,
&mask->mLengthAttributes[nsSVGMaskElement::X], bbox, aParent);
gfxContext *gfx = aContext->GetGfxContext();
gfx->Save();
nsSVGUtils::SetClipRect(gfx, aMatrix, maskArea);
gfxRect clipExtents = gfx->GetClipExtents();
clipExtents.RoundOut();
gfx->Restore();
#ifdef DEBUG_tor
fprintf(stderr, "clip extent: %f,%f %fx%f\n",
clipExtents.X(), clipExtents.Y(),
clipExtents.Width(), clipExtents.Height());
#endif
bool resultOverflows;
gfxIntSize surfaceSize =
nsSVGUtils::ConvertToSurfaceSize(gfxSize(clipExtents.Width(),
clipExtents.Height()),
&resultOverflows);
// 0 disables mask, < 0 is an error
if (surfaceSize.width <= 0 || surfaceSize.height <= 0)
return nsnull;
if (resultOverflows)
return nsnull;
nsRefPtr<gfxImageSurface> image =
new gfxImageSurface(surfaceSize, gfxASurface::ImageFormatARGB32);
if (!image || image->CairoStatus())
return nsnull;
image->SetDeviceOffset(-clipExtents.TopLeft());
nsSVGRenderState tmpState(image);
mMaskParent = aParent;
if (mMaskParentMatrix) {
*mMaskParentMatrix = aMatrix;
} else {
mMaskParentMatrix = new gfxMatrix(aMatrix);
}
for (nsIFrame* kid = mFrames.FirstChild(); kid;
kid = kid->GetNextSibling()) {
// The CTM of each frame referencing us can be different
nsISVGChildFrame* SVGFrame = do_QueryFrame(kid);
if (SVGFrame) {
SVGFrame->NotifySVGChanged(nsISVGChildFrame::SUPPRESS_INVALIDATION |
nsISVGChildFrame::TRANSFORM_CHANGED);
}
nsSVGUtils::PaintFrameWithEffects(&tmpState, nsnull, kid);
}
PRUint8 *data = image->Data();
PRInt32 stride = image->Stride();
nsIntRect rect(0, 0, surfaceSize.width, surfaceSize.height);
nsSVGUtils::UnPremultiplyImageDataAlpha(data, stride, rect);
if (GetStyleSVG()->mColorInterpolation ==
NS_STYLE_COLOR_INTERPOLATION_LINEARRGB) {
nsSVGUtils::ConvertImageDataToLinearRGB(data, stride, rect);
}
for (PRInt32 y = 0; y < surfaceSize.height; y++)
for (PRInt32 x = 0; x < surfaceSize.width; x++) {
PRUint8 *pixel = data + stride * y + 4 * x;
/* linearRGB -> intensity */
PRUint8 alpha =
static_cast<PRUint8>
((pixel[GFX_ARGB32_OFFSET_R] * 0.2125 +
pixel[GFX_ARGB32_OFFSET_G] * 0.7154 +
pixel[GFX_ARGB32_OFFSET_B] * 0.0721) *
(pixel[GFX_ARGB32_OFFSET_A] / 255.0) * aOpacity);
memset(pixel, alpha, 4);
}
gfxPattern *retval = new gfxPattern(image);
NS_IF_ADDREF(retval);
return retval;
}
nsresult
nsSVGFilterInstance::BuildSourceImages()
{
nsIntRect neededRect;
neededRect.UnionRect(mSourceColorAlpha.mResultNeededBox,
mSourceAlpha.mResultNeededBox);
if (neededRect.IsEmpty())
return NS_OK;
nsRefPtr<gfxImageSurface> sourceColorAlpha = CreateImage();
if (!sourceColorAlpha)
return NS_ERROR_OUT_OF_MEMORY;
{
// Paint to an offscreen surface first, then copy it to an image
// surface. This can be faster especially when the stuff we're painting
// contains native themes.
nsRefPtr<gfxASurface> offscreen =
gfxPlatform::GetPlatform()->CreateOffscreenSurface(
gfxIntSize(mSurfaceRect.width, mSurfaceRect.height),
gfxASurface::CONTENT_COLOR_ALPHA);
if (!offscreen || offscreen->CairoStatus())
return NS_ERROR_OUT_OF_MEMORY;
offscreen->SetDeviceOffset(gfxPoint(-mSurfaceRect.x, -mSurfaceRect.y));
nsSVGRenderState tmpState(offscreen);
gfxMatrix userSpaceToFilterSpace = GetUserSpaceToFilterSpaceTransform();
gfxRect r(neededRect.x, neededRect.y, neededRect.width, neededRect.height);
gfxMatrix m = userSpaceToFilterSpace;
m.Invert();
r = m.TransformBounds(r);
r.RoundOut();
nsIntRect dirty;
if (!gfxUtils::GfxRectToIntRect(r, &dirty))
return NS_ERROR_FAILURE;
// SVG graphics paint to device space, so we need to set an initial device
// space to filter space transform on the gfxContext that SourceGraphic
// and SourceAlpha will paint to.
//
// (In theory it would be better to minimize error by having filtered SVG
// graphics temporarily paint to user space when painting the sources and
// only set a user space to filter space transform on the gfxContext
// (since that would eliminate the transform multiplications from user
// space to device space and back again). However, that would make the
// code more complex while being hard to get right without introducing
// subtle bugs, and in practice it probably makes no real difference.)
gfxMatrix deviceToFilterSpace = GetFilterSpaceToDeviceSpaceTransform().Invert();
tmpState.GetGfxContext()->Multiply(deviceToFilterSpace);
mPaintCallback->Paint(&tmpState, mTargetFrame, &dirty);
gfxContext copyContext(sourceColorAlpha);
copyContext.SetSource(offscreen);
copyContext.Paint();
}
if (!mSourceColorAlpha.mResultNeededBox.IsEmpty()) {
NS_ASSERTION(mSourceColorAlpha.mImageUsers > 0, "Some user must have needed this");
mSourceColorAlpha.mImage.mImage = sourceColorAlpha;
// color model is PREMULTIPLIED SRGB by default.
}
if (!mSourceAlpha.mResultNeededBox.IsEmpty()) {
NS_ASSERTION(mSourceAlpha.mImageUsers > 0, "Some user must have needed this");
mSourceAlpha.mImage.mImage = CreateImage();
if (!mSourceAlpha.mImage.mImage)
return NS_ERROR_OUT_OF_MEMORY;
// color model is PREMULTIPLIED SRGB by default.
// Clear the color channel
const PRUint32* src = reinterpret_cast<PRUint32*>(sourceColorAlpha->Data());
PRUint32* dest = reinterpret_cast<PRUint32*>(mSourceAlpha.mImage.mImage->Data());
for (PRInt32 y = 0; y < mSurfaceRect.height; y++) {
PRUint32 rowOffset = (mSourceAlpha.mImage.mImage->Stride()*y) >> 2;
for (PRInt32 x = 0; x < mSurfaceRect.width; x++) {
dest[rowOffset + x] = src[rowOffset + x] & 0xFF000000U;
}
}
mSourceAlpha.mImage.mConstantColorChannels = true;
}
nsresult
nsSVGPatternFrame::PaintPattern(gfxASurface** surface,
gfxMatrix* patternMatrix,
nsSVGGeometryFrame *aSource,
float aGraphicOpacity)
{
/*
* General approach:
* Set the content geometry stuff
* Calculate our bbox (using x,y,width,height & patternUnits &
* patternTransform)
* Create the surface
* Calculate the content transformation matrix
* Get our children (we may need to get them from another Pattern)
* Call SVGPaint on all of our children
* Return
*/
*surface = nsnull;
// Get our child
nsIFrame *firstKid;
if (NS_FAILED(GetPatternFirstChild(&firstKid)))
return NS_ERROR_FAILURE; // Either no kids or a bad reference
/*
* Get the content geometry information. This is a little tricky --
* our parent is probably a <defs>, but we are rendering in the context
* of some geometry source. Our content geometry information needs to
* come from our rendering parent as opposed to our content parent. We
* get that information from aSource, which is passed to us from the
* backend renderer.
*
* There are three "geometries" that we need:
* 1) The bounding box for the pattern. We use this to get the
* width and height for the surface, and as the return to
* GetBBox.
* 2) The transformation matrix for the pattern. This is not *quite*
* the same as the canvas transformation matrix that we will
* provide to our rendering children since we "fudge" it a little
* to get the renderer to handle the translations correctly for us.
* 3) The CTM that we return to our children who make up the pattern.
*/
// Get all of the information we need from our "caller" -- i.e.
// the geometry that is being rendered with a pattern
nsSVGElement *callerContent;
nsCOMPtr<nsIDOMSVGRect> callerBBox;
nsCOMPtr<nsIDOMSVGMatrix> callerCTM;
if (NS_FAILED(GetCallerGeometry(getter_AddRefs(callerCTM),
getter_AddRefs(callerBBox),
&callerContent, aSource)))
return NS_ERROR_FAILURE;
// Construct the CTM that we will provide to our children when we
// render them into the tile.
if (NS_FAILED(ConstructCTM(getter_AddRefs(mCTM), callerBBox, callerCTM)))
return NS_ERROR_FAILURE;
// Get the bounding box of the pattern. This will be used to determine
// the size of the surface, and will also be used to define the bounding
// box for the pattern tile.
nsCOMPtr<nsIDOMSVGRect> bbox;
if (NS_FAILED(GetPatternRect(getter_AddRefs(bbox),
callerBBox, callerCTM,
callerContent)))
return NS_ERROR_FAILURE;
// Get the transformation matrix that we will hand to the renderer's pattern
// routine.
*patternMatrix = GetPatternMatrix(bbox, callerBBox, callerCTM);
#ifdef DEBUG_scooter
printRect("Geometry Rect: ", callerBBox);
printRect("Pattern Rect: ", bbox);
printCTM("Pattern TM ", *patternMatrix);
printCTM("Child TM ", mCTM);
#endif
// Now that we have all of the necessary geometries, we can
// create our surface.
float patternWidth, patternHeight;
bbox->GetWidth(&patternWidth);
bbox->GetHeight(&patternHeight);
PRBool resultOverflows;
gfxIntSize surfaceSize =
nsSVGUtils::ConvertToSurfaceSize(gfxSize(patternWidth, patternHeight),
&resultOverflows);
// 0 disables rendering, < 0 is an error
if (surfaceSize.width <= 0 || surfaceSize.height <= 0)
return NS_ERROR_FAILURE;
if (resultOverflows) {
// scale down drawing to new pattern surface size
nsCOMPtr<nsIDOMSVGMatrix> tempTM, aCTM;
NS_NewSVGMatrix(getter_AddRefs(tempTM),
surfaceSize.width / patternWidth, 0.0f,
0.0f, surfaceSize.height / patternHeight,
0.0f, 0.0f);
mCTM->Multiply(tempTM, getter_AddRefs(aCTM));
aCTM.swap(mCTM);
// and magnify pattern to compensate
patternMatrix->Scale(patternWidth / surfaceSize.width,
patternHeight / surfaceSize.height);
}
#ifdef DEBUG_scooter
printf("Creating %dX%d surface\n", int(surfaceSize.width), int(surfaceSize.height));
#endif
nsRefPtr<gfxASurface> tmpSurface =
gfxPlatform::GetPlatform()->CreateOffscreenSurface(surfaceSize,
gfxASurface::ImageFormatARGB32);
if (!tmpSurface || tmpSurface->CairoStatus())
return NS_ERROR_FAILURE;
gfxContext tmpContext(tmpSurface);
nsSVGRenderState tmpState(&tmpContext);
// Fill with transparent black
tmpContext.SetOperator(gfxContext::OPERATOR_CLEAR);
tmpContext.Paint();
tmpContext.SetOperator(gfxContext::OPERATOR_OVER);
if (aGraphicOpacity != 1.0f) {
tmpContext.Save();
tmpContext.PushGroup(gfxASurface::CONTENT_COLOR_ALPHA);
}
// OK, now render -- note that we use "firstKid", which
// we got at the beginning because it takes care of the
// referenced pattern situation for us
// Set our geometrical parent
mSource = aSource;
for (nsIFrame* kid = firstKid; kid;
kid = kid->GetNextSibling()) {
nsSVGUtils::PaintChildWithEffects(&tmpState, nsnull, kid);
}
mSource = nsnull;
if (aGraphicOpacity != 1.0f) {
tmpContext.PopGroupToSource();
tmpContext.Paint(aGraphicOpacity);
tmpContext.Restore();
}
// caller now owns the surface
tmpSurface.swap(*surface);
return NS_OK;
}
