code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
private String getStringPredicate(String fieldName, List<String> filterValues, List<Object> prms)
{
if (filterValues != null && !filterValues.isEmpty())
{
String res = "";
for (String filterValue : filterValues)
{
if (filterValue == null)
{
continue;
}
if (!filterValue.isEmpty())
{
prms.add(filterValue);
if (filterValue.contains("%"))
{
res += String.format("(%s LIKE ?) OR ", fieldName);
}
else
{
res += String.format("(%s = ?) OR ", fieldName);
}
}
else
{
res += String.format("(%s IS NULL OR %s = '') OR ", fieldName, fieldName);
}
}
if (!res.isEmpty())
{
res = "AND (" + res.substring(0, res.length() - 4) + ") ";
return res;
}
}
return "";
} | java |
public void prepare(Properties p, Connection cnx)
{
this.tablePrefix = p.getProperty("com.enioka.jqm.jdbc.tablePrefix", "");
queries.putAll(DbImplBase.queries);
for (Map.Entry<String, String> entry : DbImplBase.queries.entrySet())
{
queries.put(entry.getKey(), this.adaptSql(entry.getValue()));
}
} | java |
@Override
public boolean accept(File file) {
//All directories are added in the least that can be read by the Application
if (file.isDirectory()&&file.canRead())
{ return true;
}
else if(properties.selection_type==DialogConfigs.DIR_SELECT)
{ /* True for files, If the selection type is Directory type, ie.
* Only directory has to be selected from the list, then all files are
* ignored.
*/
return false;
}
else
{ /* Check whether name of the file ends with the extension. Added if it
* does.
*/
String name = file.getName().toLowerCase(Locale.getDefault());
for (String ext : validExtensions) {
if (name.endsWith(ext)) {
return true;
}
}
}
return false;
} | java |
public void setSize(int size) {
if (size != MaterialProgressDrawable.LARGE && size != MaterialProgressDrawable.DEFAULT) {
return;
}
final DisplayMetrics metrics = getResources().getDisplayMetrics();
if (size == MaterialProgressDrawable.LARGE) {
mCircleHeight = mCircleWidth = (int) (CIRCLE_DIAMETER_LARGE * metrics.density);
} else {
mCircleHeight = mCircleWidth = (int) (CIRCLE_DIAMETER * metrics.density);
}
// force the bounds of the progress circle inside the circle view to
// update by setting it to null before updating its size and then
// re-setting it
mCircleView.setImageDrawable(null);
mProgress.updateSizes(size);
mCircleView.setImageDrawable(mProgress);
} | java |
public void setRefreshing(boolean refreshing) {
if (refreshing && mRefreshing != refreshing) {
// scale and show
mRefreshing = refreshing;
int endTarget = 0;
if (!mUsingCustomStart) {
switch (mDirection) {
case BOTTOM:
endTarget = getMeasuredHeight() - (int) (mSpinnerFinalOffset);
break;
case TOP:
default:
endTarget = (int) (mSpinnerFinalOffset - Math.abs(mOriginalOffsetTop));
break;
}
} else {
endTarget = (int) mSpinnerFinalOffset;
}
setTargetOffsetTopAndBottom(endTarget - mCurrentTargetOffsetTop,
true /* requires update */);
mNotify = false;
startScaleUpAnimation(mRefreshListener);
} else {
setRefreshing(refreshing, false /* notify */);
}
} | java |
private void setAnimationProgress(float progress) {
if (isAlphaUsedForScale()) {
setColorViewAlpha((int) (progress * MAX_ALPHA));
} else {
ViewCompat.setScaleX(mCircleView, progress);
ViewCompat.setScaleY(mCircleView, progress);
}
} | java |
public void setProgressBackgroundColor(int colorRes) {
mCircleView.setBackgroundColor(colorRes);
mProgress.setBackgroundColor(getResources().getColor(colorRes));
} | java |
private void setRawDirection(SwipyRefreshLayoutDirection direction) {
if (mDirection == direction) {
return;
}
mDirection = direction;
switch (mDirection) {
case BOTTOM:
mCurrentTargetOffsetTop = mOriginalOffsetTop = getMeasuredHeight();
break;
case TOP:
default:
mCurrentTargetOffsetTop = mOriginalOffsetTop = -mCircleView.getMeasuredHeight();
break;
}
} | java |
public static boolean uniform(Color color, Pixel[] pixels) {
return Arrays.stream(pixels).allMatch(p -> p.toInt() == color.toRGB().toInt());
} | java |
public static int scale(Double factor, int pixel) {
return rgb(
(int) Math.round(factor * red(pixel)),
(int) Math.round(factor * green(pixel)),
(int) Math.round(factor * blue(pixel))
);
} | java |
public void set(String name, Object value) {
hashAttributes.put(name, value);
if (plugin != null) {
plugin.invalidate();
}
} | java |
public static int wavelengthToRGB(float wavelength) {
float gamma = 0.80f;
float r, g, b, factor;
int w = (int)wavelength;
if (w < 380) {
r = 0.0f;
g = 0.0f;
b = 0.0f;
} else if (w < 440) {
r = -(wavelength - 440) / (440 - 380);
g = 0.0f;
b = 1.0f;
} else if (w < 490) {
r = 0.0f;
g = (wavelength - 440) / (490 - 440);
b = 1.0f;
} else if (w < 510) {
r = 0.0f;
g = 1.0f;
b = -(wavelength - 510) / (510 - 490);
} else if (w < 580) {
r = (wavelength - 510) / (580 - 510);
g = 1.0f;
b = 0.0f;
} else if (w < 645) {
r = 1.0f;
g = -(wavelength - 645) / (645 - 580);
b = 0.0f;
} else if (w <= 780) {
r = 1.0f;
g = 0.0f;
b = 0.0f;
} else {
r = 0.0f;
g = 0.0f;
b = 0.0f;
}
// Let the intensity fall off near the vision limits
if (380 <= w && w <= 419)
factor = 0.3f + 0.7f*(wavelength - 380) / (420 - 380);
else if (420 <= w && w <= 700)
factor = 1.0f;
else if (701 <= w && w <= 780)
factor = 0.3f + 0.7f*(780 - wavelength) / (780 - 700);
else
factor = 0.0f;
int ir = adjust(r, factor, gamma);
int ig = adjust(g, factor, gamma);
int ib = adjust(b, factor, gamma);
return 0xff000000 | (ir << 16) | (ig << 8) | ib;
} | java |
public static void convolveHV(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha, int edgeAction) {
int index = 0;
float[] matrix = kernel.getKernelData( null );
int rows = kernel.getHeight();
int cols = kernel.getWidth();
int rows2 = rows/2;
int cols2 = cols/2;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float r = 0, g = 0, b = 0, a = 0;
for (int row = -rows2; row <= rows2; row++) {
int iy = y+row;
int ioffset;
if (0 <= iy && iy < height)
ioffset = iy*width;
else if ( edgeAction == CLAMP_EDGES )
ioffset = y*width;
else if ( edgeAction == WRAP_EDGES )
ioffset = ((iy+height) % height) * width;
else
continue;
int moffset = cols*(row+rows2)+cols2;
for (int col = -cols2; col <= cols2; col++) {
float f = matrix[moffset+col];
if (f != 0) {
int ix = x+col;
if (!(0 <= ix && ix < width)) {
if ( edgeAction == CLAMP_EDGES )
ix = x;
else if ( edgeAction == WRAP_EDGES )
ix = (x+width) % width;
else
continue;
}
int rgb = inPixels[ioffset+ix];
a += f * ((rgb >> 24) & 0xff);
r += f * ((rgb >> 16) & 0xff);
g += f * ((rgb >> 8) & 0xff);
b += f * (rgb & 0xff);
}
}
}
int ia = alpha ? PixelUtils.clamp((int)(a+0.5)) : 0xff;
int ir = PixelUtils.clamp((int)(r+0.5));
int ig = PixelUtils.clamp((int)(g+0.5));
int ib = PixelUtils.clamp((int)(b+0.5));
outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
}
}
} | java |
private void initPixelsArray(BufferedImage image) {
int width = image.getWidth();
int height = image.getHeight();
pixels = new int[width * height];
image.getRGB(0, 0, width, height, pixels, 0, width);
} | java |
private int[] changeColor() {
int[] changedPixels = new int[pixels.length];
double frequenz = 2 * Math.PI / 1020;
for (int i = 0; i < pixels.length; i++) {
int argb = pixels[i];
int a = (argb >> 24) & 0xff;
int r = (argb >> 16) & 0xff;
int g = (argb >> 8) & 0xff;
int b = argb & 0xff;
r = (int) (255 * Math.sin(frequenz * r));
b = (int) (-255 * Math.cos(frequenz * b) + 255);
changedPixels[i] = (a << 24) | (r << 16) | (g << 8) | b;
}
return changedPixels;
} | java |
private static Set<String> imageOrientationsOf(ImageMetadata metadata) {
String exifIFD0DirName = new ExifIFD0Directory().getName();
Tag[] tags = Arrays.stream(metadata.getDirectories())
.filter(dir -> dir.getName().equals(exifIFD0DirName))
.findFirst()
.map(Directory::getTags)
.orElseGet(() -> new Tag[0]);
return Arrays.stream(tags)
.filter(tag -> tag.getType() == 274)
.map(Tag::getRawValue)
.collect(Collectors.toSet());
} | java |
public static float noise1(float x) {
int bx0, bx1;
float rx0, rx1, sx, t, u, v;
if (start) {
start = false;
init();
}
t = x + N;
bx0 = ((int)t) & BM;
bx1 = (bx0+1) & BM;
rx0 = t - (int)t;
rx1 = rx0 - 1.0f;
sx = sCurve(rx0);
u = rx0 * g1[p[bx0]];
v = rx1 * g1[p[bx1]];
return 2.3f*lerp(sx, u, v);
} | java |
public static float noise2(float x, float y) {
int bx0, bx1, by0, by1, b00, b10, b01, b11;
float rx0, rx1, ry0, ry1, q[], sx, sy, a, b, t, u, v;
int i, j;
if (start) {
start = false;
init();
}
t = x + N;
bx0 = ((int)t) & BM;
bx1 = (bx0+1) & BM;
rx0 = t - (int)t;
rx1 = rx0 - 1.0f;
t = y + N;
by0 = ((int)t) & BM;
by1 = (by0+1) & BM;
ry0 = t - (int)t;
ry1 = ry0 - 1.0f;
i = p[bx0];
j = p[bx1];
b00 = p[i + by0];
b10 = p[j + by0];
b01 = p[i + by1];
b11 = p[j + by1];
sx = sCurve(rx0);
sy = sCurve(ry0);
q = g2[b00]; u = rx0 * q[0] + ry0 * q[1];
q = g2[b10]; v = rx1 * q[0] + ry0 * q[1];
a = lerp(sx, u, v);
q = g2[b01]; u = rx0 * q[0] + ry1 * q[1];
q = g2[b11]; v = rx1 * q[0] + ry1 * q[1];
b = lerp(sx, u, v);
return 1.5f*lerp(sy, a, b);
} | java |
private List<Pair<Integer, Double>> integerPixelCoordinatesAndWeights(double d, int numPixels) {
if (d <= 0.5) return Collections.singletonList(new Pair<>(0, 1.0));
else if (d >= numPixels - 0.5) return Collections.singletonList(new Pair<>(numPixels - 1, 1.0));
else {
double shifted = d - 0.5;
double floor = Math.floor(shifted);
double floorWeight = 1 - (shifted - floor);
double ceil = Math.ceil(shifted);
double ceilWeight = 1 - floorWeight;
assert (floorWeight + ceilWeight == 1);
return Arrays.asList(new Pair<>((int) floor, floorWeight), new Pair<>((int) ceil, ceilWeight));
}
} | java |
public static BufferedImage createImage(ImageProducer producer) {
PixelGrabber pg = new PixelGrabber(producer, 0, 0, -1, -1, null, 0, 0);
try {
pg.grabPixels();
} catch (InterruptedException e) {
throw new RuntimeException("Image fetch interrupted");
}
if ((pg.status() & ImageObserver.ABORT) != 0)
throw new RuntimeException("Image fetch aborted");
if ((pg.status() & ImageObserver.ERROR) != 0)
throw new RuntimeException("Image fetch error");
BufferedImage p = new BufferedImage(pg.getWidth(), pg.getHeight(), BufferedImage.TYPE_INT_ARGB);
p.setRGB(0, 0, pg.getWidth(), pg.getHeight(), (int[])pg.getPixels(), 0, pg.getWidth());
return p;
} | java |
public static BufferedImage convertImageToARGB( Image image ) {
if ( image instanceof BufferedImage && ((BufferedImage)image).getType() == BufferedImage.TYPE_INT_ARGB )
return (BufferedImage)image;
BufferedImage p = new BufferedImage( image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_ARGB);
Graphics2D g = p.createGraphics();
g.drawImage( image, 0, 0, null );
g.dispose();
return p;
} | java |
public static BufferedImage cloneImage( BufferedImage image ) {
BufferedImage newImage = new BufferedImage( image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB );
Graphics2D g = newImage.createGraphics();
g.drawRenderedImage( image, null );
g.dispose();
return newImage;
} | java |
public static void paintCheckedBackground(Component c, Graphics g, int x, int y, int width, int height) {
if ( backgroundImage == null ) {
backgroundImage = new BufferedImage( 64, 64, BufferedImage.TYPE_INT_ARGB );
Graphics bg = backgroundImage.createGraphics();
for ( int by = 0; by < 64; by += 8 ) {
for ( int bx = 0; bx < 64; bx += 8 ) {
bg.setColor( ((bx^by) & 8) != 0 ? Color.lightGray : Color.white );
bg.fillRect( bx, by, 8, 8 );
}
}
bg.dispose();
}
if ( backgroundImage != null ) {
Shape saveClip = g.getClip();
Rectangle r = g.getClipBounds();
if (r == null)
r = new Rectangle(c.getSize());
r = r.intersection(new Rectangle(x, y, width, height));
g.setClip(r);
int w = backgroundImage.getWidth();
int h = backgroundImage.getHeight();
if (w != -1 && h != -1) {
int x1 = (r.x / w) * w;
int y1 = (r.y / h) * h;
int x2 = ((r.x + r.width + w - 1) / w) * w;
int y2 = ((r.y + r.height + h - 1) / h) * h;
for (y = y1; y < y2; y += h)
for (x = x1; x < x2; x += w)
g.drawImage(backgroundImage, x, y, c);
}
g.setClip(saveClip);
}
} | java |
public static Rectangle getSelectedBounds(BufferedImage p) {
int width = p.getWidth();
int height = p.getHeight();
int maxX = 0, maxY = 0, minX = width, minY = height;
boolean anySelected = false;
int y1;
int [] pixels = null;
for (y1 = height-1; y1 >= 0; y1--) {
pixels = getRGB( p, 0, y1, width, 1, pixels );
for (int x = 0; x < minX; x++) {
if ((pixels[x] & 0xff000000) != 0) {
minX = x;
maxY = y1;
anySelected = true;
break;
}
}
for (int x = width-1; x >= maxX; x--) {
if ((pixels[x] & 0xff000000) != 0) {
maxX = x;
maxY = y1;
anySelected = true;
break;
}
}
if ( anySelected )
break;
}
pixels = null;
for (int y = 0; y < y1; y++) {
pixels = getRGB( p, 0, y, width, 1, pixels );
for (int x = 0; x < minX; x++) {
if ((pixels[x] & 0xff000000) != 0) {
minX = x;
if ( y < minY )
minY = y;
anySelected = true;
break;
}
}
for (int x = width-1; x >= maxX; x--) {
if ((pixels[x] & 0xff000000) != 0) {
maxX = x;
if ( y < minY )
minY = y;
anySelected = true;
break;
}
}
}
if ( anySelected )
return new Rectangle( minX, minY, maxX-minX+1, maxY-minY+1 );
return null;
} | java |
public static void composeThroughMask(Raster src, WritableRaster dst, Raster sel) {
int x = src.getMinX();
int y = src.getMinY();
int w = src.getWidth();
int h = src.getHeight();
int srcRGB[] = null;
int selRGB[] = null;
int dstRGB[] = null;
for ( int i = 0; i < h; i++ ) {
srcRGB = src.getPixels(x, y, w, 1, srcRGB);
selRGB = sel.getPixels(x, y, w, 1, selRGB);
dstRGB = dst.getPixels(x, y, w, 1, dstRGB);
int k = x;
for ( int j = 0; j < w; j++ ) {
int sr = srcRGB[k];
int dir = dstRGB[k];
int sg = srcRGB[k+1];
int dig = dstRGB[k+1];
int sb = srcRGB[k+2];
int dib = dstRGB[k+2];
int sa = srcRGB[k+3];
int dia = dstRGB[k+3];
float a = selRGB[k+3]/255f;
float ac = 1-a;
dstRGB[k] = (int)(a*sr + ac*dir);
dstRGB[k+1] = (int)(a*sg + ac*dig);
dstRGB[k+2] = (int)(a*sb + ac*dib);
dstRGB[k+3] = (int)(a*sa + ac*dia);
k += 4;
}
dst.setPixels(x, y, w, 1, dstRGB);
y++;
}
} | java |
public void setMatrix(int[] matrix) {
this.matrix = matrix;
sum = 0;
for (int i = 0; i < matrix.length; i++)
sum += matrix[i];
} | java |
public static float gain(float a, float b) {
/*
float p = (float)Math.log(1.0 - b) / (float)Math.log(0.5);
if (a < .001)
return 0.0f;
else if (a > .999)
return 1.0f;
if (a < 0.5)
return (float)Math.pow(2 * a, p) / 2;
else
return 1.0f - (float)Math.pow(2 * (1. - a), p) / 2;
*/
float c = (1.0f/b-2.0f) * (1.0f-2.0f*a);
if (a < 0.5)
return a/(c+1.0f);
else
return (c-a)/(c-1.0f);
} | java |
public static float smoothPulse(float a1, float a2, float b1, float b2, float x) {
if (x < a1 || x >= b2)
return 0;
if (x >= a2) {
if (x < b1)
return 1.0f;
x = (x - b1) / (b2 - b1);
return 1.0f - (x*x * (3.0f - 2.0f*x));
}
x = (x - a1) / (a2 - a1);
return x*x * (3.0f - 2.0f*x);
} | java |
public static float smoothStep(float a, float b, float x) {
if (x < a)
return 0;
if (x >= b)
return 1;
x = (x - a) / (b - a);
return x*x * (3 - 2*x);
} | java |
public static int mixColors(float t, int rgb1, int rgb2) {
int a1 = (rgb1 >> 24) & 0xff;
int r1 = (rgb1 >> 16) & 0xff;
int g1 = (rgb1 >> 8) & 0xff;
int b1 = rgb1 & 0xff;
int a2 = (rgb2 >> 24) & 0xff;
int r2 = (rgb2 >> 16) & 0xff;
int g2 = (rgb2 >> 8) & 0xff;
int b2 = rgb2 & 0xff;
a1 = lerp(t, a1, a2);
r1 = lerp(t, r1, r2);
g1 = lerp(t, g1, g2);
b1 = lerp(t, b1, b2);
return (a1 << 24) | (r1 << 16) | (g1 << 8) | b1;
} | java |
public static int bilinearInterpolate(float x, float y, int nw, int ne, int sw, int se) {
float m0, m1;
int a0 = (nw >> 24) & 0xff;
int r0 = (nw >> 16) & 0xff;
int g0 = (nw >> 8) & 0xff;
int b0 = nw & 0xff;
int a1 = (ne >> 24) & 0xff;
int r1 = (ne >> 16) & 0xff;
int g1 = (ne >> 8) & 0xff;
int b1 = ne & 0xff;
int a2 = (sw >> 24) & 0xff;
int r2 = (sw >> 16) & 0xff;
int g2 = (sw >> 8) & 0xff;
int b2 = sw & 0xff;
int a3 = (se >> 24) & 0xff;
int r3 = (se >> 16) & 0xff;
int g3 = (se >> 8) & 0xff;
int b3 = se & 0xff;
float cx = 1.0f-x;
float cy = 1.0f-y;
m0 = cx * a0 + x * a1;
m1 = cx * a2 + x * a3;
int a = (int)(cy * m0 + y * m1);
m0 = cx * r0 + x * r1;
m1 = cx * r2 + x * r3;
int r = (int)(cy * m0 + y * m1);
m0 = cx * g0 + x * g1;
m1 = cx * g2 + x * g3;
int g = (int)(cy * m0 + y * m1);
m0 = cx * b0 + x * b1;
m1 = cx * b2 + x * b3;
int b = (int)(cy * m0 + y * m1);
return (a << 24) | (r << 16) | (g << 8) | b;
} | java |
public static int brightnessNTSC(int rgb) {
int r = (rgb >> 16) & 0xff;
int g = (rgb >> 8) & 0xff;
int b = rgb & 0xff;
return (int)(r*0.299f + g*0.587f + b*0.114f);
} | java |
public static int colorSpline(int x, int numKnots, int[] xknots, int[] yknots) {
int span;
int numSpans = numKnots - 3;
float k0, k1, k2, k3;
float c0, c1, c2, c3;
if (numSpans < 1)
throw new IllegalArgumentException("Too few knots in spline");
for (span = 0; span < numSpans; span++)
if (xknots[span+1] > x)
break;
if (span > numKnots-3)
span = numKnots-3;
float t = (float)(x-xknots[span]) / (xknots[span+1]-xknots[span]);
span--;
if (span < 0) {
span = 0;
t = 0;
}
int v = 0;
for (int i = 0; i < 4; i++) {
int shift = i * 8;
k0 = (yknots[span] >> shift) & 0xff;
k1 = (yknots[span+1] >> shift) & 0xff;
k2 = (yknots[span+2] >> shift) & 0xff;
k3 = (yknots[span+3] >> shift) & 0xff;
c3 = m00*k0 + m01*k1 + m02*k2 + m03*k3;
c2 = m10*k0 + m11*k1 + m12*k2 + m13*k3;
c1 = m20*k0 + m21*k1 + m22*k2 + m23*k3;
c0 = m30*k0 + m31*k1 + m32*k2 + m33*k3;
int n = (int)(((c3*t + c2)*t + c1)*t + c0);
if (n < 0)
n = 0;
else if (n > 255)
n = 255;
v |= n << shift;
}
return v;
} | java |
public void copyTo(Gradient g) {
g.numKnots = numKnots;
g.map = (int[])map.clone();
g.xKnots = (int[])xKnots.clone();
g.yKnots = (int[])yKnots.clone();
g.knotTypes = (byte[])knotTypes.clone();
} | java |
public void setColor(int n, int color) {
int firstColor = map[0];
int lastColor = map[256-1];
if (n > 0)
for (int i = 0; i < n; i++)
map[i] = ImageMath.mixColors((float)i/n, firstColor, color);
if (n < 256-1)
for (int i = n; i < 256; i++)
map[i] = ImageMath.mixColors((float)(i-n)/(256-n), color, lastColor);
} | java |
public void setKnotType(int n, int type) {
knotTypes[n] = (byte)((knotTypes[n] & ~COLOR_MASK) | type);
rebuildGradient();
} | java |
public void setKnotBlend(int n, int type) {
knotTypes[n] = (byte)((knotTypes[n] & ~BLEND_MASK) | type);
rebuildGradient();
} | java |
public void setKnots(int[] x, int[] rgb, byte[] types) {
numKnots = rgb.length+2;
xKnots = new int[numKnots];
yKnots = new int[numKnots];
knotTypes = new byte[numKnots];
if (x != null)
System.arraycopy(x, 0, xKnots, 1, numKnots-2);
else
for (int i = 1; i > numKnots-1; i++)
xKnots[i] = 255*i/(numKnots-2);
System.arraycopy(rgb, 0, yKnots, 1, numKnots-2);
if (types != null)
System.arraycopy(types, 0, knotTypes, 1, numKnots-2);
else
for (int i = 0; i > numKnots; i++)
knotTypes[i] = RGB|SPLINE;
sortKnots();
rebuildGradient();
} | java |
public void setKnots(int[] x, int[] y, byte[] types, int offset, int count) {
numKnots = count;
xKnots = new int[numKnots];
yKnots = new int[numKnots];
knotTypes = new byte[numKnots];
System.arraycopy(x, offset, xKnots, 0, numKnots);
System.arraycopy(y, offset, yKnots, 0, numKnots);
System.arraycopy(types, offset, knotTypes, 0, numKnots);
sortKnots();
rebuildGradient();
} | java |
public void splitSpan(int n) {
int x = (xKnots[n] + xKnots[n+1])/2;
addKnot(x, getColor(x/256.0f), knotTypes[n]);
rebuildGradient();
} | java |
public int knotAt(int x) {
for (int i = 1; i < numKnots-1; i++)
if (xKnots[i+1] > x)
return i;
return 1;
} | java |
public void randomize() {
numKnots = 4 + (int)(6*Math.random());
xKnots = new int[numKnots];
yKnots = new int[numKnots];
knotTypes = new byte[numKnots];
for (int i = 0; i < numKnots; i++) {
xKnots[i] = (int)(255 * Math.random());
yKnots[i] = 0xff000000 | ((int)(255 * Math.random()) << 16) | ((int)(255 * Math.random()) << 8) | (int)(255 * Math.random());
knotTypes[i] = RGB|SPLINE;
}
xKnots[0] = -1;
xKnots[1] = 0;
xKnots[numKnots-2] = 255;
xKnots[numKnots-1] = 256;
sortKnots();
rebuildGradient();
} | java |
public void mutate(float amount) {
for (int i = 0; i < numKnots; i++) {
int rgb = yKnots[i];
int r = ((rgb >> 16) & 0xff);
int g = ((rgb >> 8) & 0xff);
int b = (rgb & 0xff);
r = PixelUtils.clamp( (int)(r + amount * 255 * (Math.random()-0.5)) );
g = PixelUtils.clamp( (int)(g + amount * 255 * (Math.random()-0.5)) );
b = PixelUtils.clamp( (int)(b + amount * 255 * (Math.random()-0.5)) );
yKnots[i] = 0xff000000 | (r << 16) | (g << 8) | b;
knotTypes[i] = RGB|SPLINE;
}
sortKnots();
rebuildGradient();
} | java |
public void setBufferedImage(BufferedImage img) {
image = img;
width = img.getWidth();
height = img.getHeight();
updateColorArray();
} | java |
public BufferedImage getNewImageInstance() {
BufferedImage buf = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
buf.setData(image.getData());
return buf;
} | java |
public BufferedImage getBufferedImage(int width, int height) {
// using the new approach of Java 2D API
BufferedImage buf = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2d = (Graphics2D) buf.getGraphics();
g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g2d.drawImage(image, 0, 0, width, height, null);
g2d.dispose();
return (buf);
} | java |
public void resize(int w, int h) {
// using the new approach of Java 2D API
BufferedImage buf = new BufferedImage(w, h, image.getType());
Graphics2D g2d = (Graphics2D) buf.getGraphics();
g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g2d.drawImage(image, 0, 0, w, h, null);
g2d.dispose();
image = buf;
width = w;
height = h;
updateColorArray();
} | java |
public double multi8p(int x, int y, double masc) {
int aR = getIntComponent0(x - 1, y - 1);
int bR = getIntComponent0(x - 1, y);
int cR = getIntComponent0(x - 1, y + 1);
int aG = getIntComponent1(x - 1, y - 1);
int bG = getIntComponent1(x - 1, y);
int cG = getIntComponent1(x - 1, y + 1);
int aB = getIntComponent1(x - 1, y - 1);
int bB = getIntComponent1(x - 1, y);
int cB = getIntComponent1(x - 1, y + 1);
int dR = getIntComponent0(x, y - 1);
int eR = getIntComponent0(x, y);
int fR = getIntComponent0(x, y + 1);
int dG = getIntComponent1(x, y - 1);
int eG = getIntComponent1(x, y);
int fG = getIntComponent1(x, y + 1);
int dB = getIntComponent1(x, y - 1);
int eB = getIntComponent1(x, y);
int fB = getIntComponent1(x, y + 1);
int gR = getIntComponent0(x + 1, y - 1);
int hR = getIntComponent0(x + 1, y);
int iR = getIntComponent0(x + 1, y + 1);
int gG = getIntComponent1(x + 1, y - 1);
int hG = getIntComponent1(x + 1, y);
int iG = getIntComponent1(x + 1, y + 1);
int gB = getIntComponent1(x + 1, y - 1);
int hB = getIntComponent1(x + 1, y);
int iB = getIntComponent1(x + 1, y + 1);
double rgb = 0;
rgb = ((aR * masc) + (bR * masc) + (cR * masc) +
(dR * masc) + (eR * masc) + (fR * masc) +
(gR * masc) + (hR * masc) + (iR * masc));
return (rgb);
} | java |
public void fillRect(int x, int y, int w, int h, Color c) {
int color = c.getRGB();
for (int i = x; i < x + w; i++) {
for (int j = y; j < y + h; j++) {
setIntColor(i, j, color);
}
}
} | java |
public void prepareFilter( float transition ) {
try {
method.invoke( filter, new Object[] { new Float( transition ) } );
}
catch ( Exception e ) {
throw new IllegalArgumentException("Error setting value for property: "+property);
}
} | java |
public static MarvinImage rgbToBinary(MarvinImage img, int threshold) {
MarvinImage resultImage = new MarvinImage(img.getWidth(), img.getHeight(), MarvinImage.COLOR_MODEL_BINARY);
for (int y = 0; y < img.getHeight(); y++) {
for (int x = 0; x < img.getWidth(); x++) {
int gray = (int) ((img.getIntComponent0(x, y) * 0.3) + (img.getIntComponent1(x, y) * 0.59) + (img.getIntComponent2(x, y) * 0.11));
if (gray <= threshold) {
resultImage.setBinaryColor(x, y, true);
} else {
resultImage.setBinaryColor(x, y, false);
}
}
}
return resultImage;
} | java |
public static MarvinImage binaryToRgb(MarvinImage img) {
MarvinImage resultImage = new MarvinImage(img.getWidth(), img.getHeight(), MarvinImage.COLOR_MODEL_RGB);
for (int y = 0; y < img.getHeight(); y++) {
for (int x = 0; x < img.getWidth(); x++) {
if (img.getBinaryColor(x, y)) {
resultImage.setIntColor(x, y, 0, 0, 0);
} else {
resultImage.setIntColor(x, y, 255, 255, 255);
}
}
}
return resultImage;
} | java |
public static int[] binaryToRgb(boolean[] binaryArray) {
int[] rgbArray = new int[binaryArray.length];
for (int i = 0; i < binaryArray.length; i++) {
if (binaryArray[i]) {
rgbArray[i] = 0x00000000;
} else {
rgbArray[i] = 0x00FFFFFF;
}
}
return rgbArray;
} | java |
public void setAngle(float angle) {
this.angle = angle;
float cos = (float) Math.cos(angle);
float sin = (float) Math.sin(angle);
m00 = cos;
m01 = sin;
m10 = -sin;
m11 = cos;
} | java |
public static int scanright(Color color, int height, int width, int col, PixelsExtractor f, int tolerance) {
if (col == width || !PixelTools.colorMatches(color, tolerance, f.apply(new Area(col, 0, 1, height))))
return col;
else
return scanright(color, height, width, col + 1, f, tolerance);
} | java |
public void clear() {
if (arrMask != null) {
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
arrMask[x][y] = false;
}
}
}
} | java |
public Pixel[] pixels() {
Pixel[] pixels = new Pixel[count()];
Point[] points = points();
for (int k = 0; k < points.length; k++) {
pixels[k] = pixel(points[k]);
}
return pixels;
} | java |
public boolean forall(PixelPredicate predicate) {
return Arrays.stream(points()).allMatch(p -> predicate.test(p.x, p.y, pixel(p)));
} | java |
public void foreach(PixelFunction fn) {
Arrays.stream(points()).forEach(p -> fn.apply(p.x, p.y, pixel(p)));
} | java |
public boolean contains(Color color) {
return exists(p -> p.toInt() == color.toPixel().toInt());
} | java |
public int[] argb(int x, int y) {
Pixel p = pixel(x, y);
return new int[]{p.alpha(), p.red(), p.green(), p.blue()};
} | java |
public int[][] argb() {
return Arrays.stream(points()).map(p -> argb(p.x, p.y)).toArray(int[][]::new);
} | java |
public Set<RGBColor> colours() {
return stream().map(Pixel::toColor).collect(Collectors.toSet());
} | java |
public BufferedImage toNewBufferedImage(int type) {
BufferedImage target = new BufferedImage(width, height, type);
Graphics2D g2 = (Graphics2D) target.getGraphics();
g2.drawImage(awt, 0, 0, null);
g2.dispose();
return target;
} | java |
public static Dimension dimensionsToFit(Dimension target, Dimension source) {
// if target width/height is zero then we have no preference for that, so set it to the original value,
// since it cannot be any larger
int maxWidth;
if (target.getX() == 0) {
maxWidth = source.getX();
} else {
maxWidth = target.getX();
}
int maxHeight;
if (target.getY() == 0) {
maxHeight = source.getY();
} else {
maxHeight = target.getY();
}
double wscale = maxWidth / (double) source.getX();
double hscale = maxHeight / (double) source.getY();
if (wscale < hscale)
return new Dimension((int) (source.getX() * wscale), (int) (source.getY() * wscale));
else
return new Dimension((int) (source.getX() * hscale), (int) (source.getY() * hscale));
} | java |
public void setGamma(float rGamma, float gGamma, float bGamma) {
this.rGamma = rGamma;
this.gGamma = gGamma;
this.bGamma = bGamma;
initialized = false;
} | java |
public void setColorInterpolated(int index, int firstIndex, int lastIndex, int color) {
int firstColor = map[firstIndex];
int lastColor = map[lastIndex];
for (int i = firstIndex; i <= index; i++)
map[i] = ImageMath.mixColors((float)(i-firstIndex)/(index-firstIndex), firstColor, color);
for (int i = index; i < lastIndex; i++)
map[i] = ImageMath.mixColors((float)(i-index)/(lastIndex-index), color, lastColor);
} | java |
public void setColorRange(int firstIndex, int lastIndex, int color1, int color2) {
for (int i = firstIndex; i <= lastIndex; i++)
map[i] = ImageMath.mixColors((float)(i-firstIndex)/(lastIndex-firstIndex), color1, color2);
} | java |
public void setColorRange(int firstIndex, int lastIndex, int color) {
for (int i = firstIndex; i <= lastIndex; i++)
map[i] = color;
} | java |
public void buttonClick(View v) {
switch (v.getId()) {
case R.id.show:
showAppMsg();
break;
case R.id.cancel_all:
AppMsg.cancelAll(this);
break;
default:
return;
}
} | java |
public LayoutParams getLayoutParams() {
if (mLayoutParams == null) {
mLayoutParams = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
}
return mLayoutParams;
} | java |
public AppMsg setLayoutGravity(int gravity) {
mLayoutParams = new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT, gravity);
return this;
} | java |
public static int getPercentage(String percentage) {
if (isNotEmpty(percentage) && isNumeric(percentage)) {
int p = Integer.parseInt(percentage);
return p;
} else {
return 0;
}
} | java |
public App named(String name) {
App newApp = copy();
newApp.name = name;
return newApp;
} | java |
public App on(Heroku.Stack stack) {
App newApp = copy();
newApp.stack = new App.Stack(stack);
return newApp;
} | java |
public Range<App> listApps(String range) {
return connection.execute(new AppList(range), apiKey);
} | java |
public String renameApp(String appName, String newName) {
return connection.execute(new AppRename(appName, newName), apiKey).getName();
} | java |
public AddonChange addAddon(String appName, String addonName) {
return connection.execute(new AddonInstall(appName, addonName), apiKey);
} | java |
public List<Addon> listAppAddons(String appName) {
return connection.execute(new AppAddonsList(appName), apiKey);
} | java |
public AddonChange removeAddon(String appName, String addonName) {
return connection.execute(new AddonRemove(appName, addonName), apiKey);
} | java |
public List<Release> listReleases(String appName) {
return connection.execute(new ReleaseList(appName), apiKey);
} | java |
public Release rollback(String appName, String releaseUuid) {
return connection.execute(new Rollback(appName, releaseUuid), apiKey);
} | java |
public Release getReleaseInfo(String appName, String releaseName) {
return connection.execute(new ReleaseInfo(appName, releaseName), apiKey);
} | java |
public List<Collaborator> listCollaborators(String appName) {
return connection.execute(new CollabList(appName), apiKey);
} | java |
public void addCollaborator(String appName, String collaborator) {
connection.execute(new SharingAdd(appName, collaborator), apiKey);
} | java |
public void removeCollaborator(String appName, String collaborator) {
connection.execute(new SharingRemove(appName, collaborator), apiKey);
} | java |
public void updateConfig(String appName, Map<String, String> config) {
connection.execute(new ConfigUpdate(appName, config), apiKey);
} | java |
public Map<String, String> listConfig(String appName) {
return connection.execute(new ConfigList(appName), apiKey);
} | java |
public void transferApp(String appName, String to) {
connection.execute(new SharingTransfer(appName, to), apiKey);
} | java |
public LogStreamResponse getLogs(String appName, Boolean tail) {
return connection.execute(new Log(appName, tail), apiKey);
} | java |
public LogStreamResponse getLogs(Log.LogRequestBuilder logRequest) {
return connection.execute(new Log(logRequest), apiKey);
} | java |
public boolean isMaintenanceModeEnabled(String appName) {
App app = connection.execute(new AppInfo(appName), apiKey);
return app.isMaintenance();
} | java |
public void setMaintenanceMode(String appName, boolean enable) {
connection.execute(new AppUpdate(appName, enable), apiKey);
} | java |
public Build createBuild(String appName, Build build) {
return connection.execute(new BuildCreate(appName, build), apiKey);
} | java |
public Build getBuildInfo(String appName, String buildId) {
return connection.execute(new BuildInfo(appName, buildId), apiKey);
} | java |
public Range<Dyno> listDynos(String appName) {
return connection.execute(new DynoList(appName), apiKey);
} | java |
public void restartDyno(String appName, String dynoId) {
connection.execute(new DynoRestart(appName, dynoId), apiKey);
} | java |
public Formation scale(String appName, String processType, int quantity) {
return connection.execute(new FormationUpdate(appName, processType, quantity), apiKey);
} | java |
public List<Formation> listFormation(String appName) {
return connection.execute(new FormationList(appName), apiKey);
} | java |
public List<BuildpackInstallation> listBuildpackInstallations(String appName) {
return connection.execute(new BuildpackInstallationList(appName), apiKey);
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.