import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
@Override
public void actionPerformed(ActionEvent e) {
	final String rawcmd = e.getActionCommand();
	final String cmd = rawcmd.substring(rawcmd.indexOf(".") + 1);

	if (rawcmd.startsWith("ColourSpace.")) {
		// change the colour space to the one selected
		this.colourSpace = ColourSpace.valueOf(cmd);
		this.classes.clear();
		this.points.clear();
	} else if (rawcmd.startsWith("button.")) {
		if (cmd.equals("learn")) {
			doLearn(lastMean, this.classType.getSelectedIndex());
		}
	}
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
@Override
public JPanel getComponent(int width, int height) throws IOException {
	final JPanel base = super.getComponent(width, height);

	// add a listener for new video frames
	vc.getDisplay().addVideoListener(this);

	// the controls panel
	final JPanel controlsPanel = new JPanel(new GridLayout(0, 1));
	controlsPanel.setOpaque(false);
	final ButtonGroup group = new ButtonGroup();

	for (final ColourSpace c : colourSpaces)
		createRadioButton(controlsPanel, group, c);

	base.add(controlsPanel);

	return base;
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
/**
 * Convert the colour space of an image, maintaining three bands so it can
 * be displayed
 *
 * @param frame
 * @param colourSpace
 */
public static void convertColours(MBFImage frame, ColourSpace colourSpace) {
	// update the frame from the camera by converting to the selected colour
	// space before display
	final MBFImage cvt = colourSpace.convert(frame);

	// if the converted image has fewer than 3 bands, add more so it can be
	// displayed as RGB.
	if (cvt.numBands() == 1) {
		// this makes a three-band grey-level image, where all the bands are
		// the same
		cvt.bands.add(cvt.getBand(0).clone());
		cvt.bands.add(cvt.getBand(0).clone());
	} else if (cvt.numBands() == 2) {
		// this adds a third zero band to a two-band image
		cvt.bands.add(new FImage(cvt.getWidth(), cvt.getHeight()));
	}

	// this sets the frame to the colour converted version
	frame.internalAssign(cvt);
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
AnimatedVideo<MBFImage> makeVideo(final Scene scene) {
	return new AnimatedVideo<MBFImage>(new MBFImage(500, 500, ColourSpace.RGB)) {
		float angle = 0;

		@Override
		protected void updateNextFrame(MBFImage frame) {
			frame.fill(RGBColour.BLACK);
			scene.renderOrtho(
					Simple3D.euler2Rot(Math.PI / 4, angle, 0),
					frame);
			angle += (2 * Math.PI / 360);
			if (angle >= Math.PI * 2)
				angle -= 2 * Math.PI;
		}
	};
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
MBFImage plot2d(double[][] data) {
	final MBFImage img = new MBFImage(500, 500, ColourSpace.RGB);

	img.drawLine(img.getWidth() / 2, img.getHeight() - 50, img.getWidth() / 2, 50, 3, RGBColour.RED);
	img.drawLine(img.getWidth() / 2 - 10, 70, img.getWidth() / 2, 50, 3, RGBColour.RED);
	img.drawLine(img.getWidth() / 2 + 10, 70, img.getWidth() / 2, 50, 3, RGBColour.RED);
	img.drawText("EV2", img.getWidth() / 2 - 80, 70, HersheyFont.ROMAN_DUPLEX, 40, RGBColour.RED);

	img.drawLine(50, img.getHeight() / 2, img.getWidth() - 50, img.getHeight() / 2, 3, RGBColour.RED);
	img.drawLine(img.getWidth() - 70, img.getHeight() / 2 + 10, img.getWidth() - 50, img.getHeight() / 2, 3,
			RGBColour.RED);
	img.drawLine(img.getWidth() - 70, img.getHeight() / 2 - 10, img.getWidth() - 50, img.getHeight() / 2, 3,
			RGBColour.RED);
	img.drawText("EV1", img.getWidth() - 70, img.getHeight() / 2 + 50, HersheyFont.ROMAN_DUPLEX, 40, RGBColour.RED);

	for (final double[] d : data) {
		img.drawPoint(new Point2dImpl(img.getWidth() / 2 - (float) d[0], img.getHeight() / 2 - (float) d[1]),
				RGBColour.GREEN, 3);
	}

	return img;
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
MBFImage plot1d(double[][] data) {
	final MBFImage img = new MBFImage(500, 500, ColourSpace.RGB);

	img.drawLine(50, img.getHeight() / 2, img.getWidth() - 50, img.getHeight() / 2, 3, RGBColour.RED);
	img.drawLine(img.getWidth() - 70, img.getHeight() / 2 + 10, img.getWidth() - 50, img.getHeight() / 2, 3,
			RGBColour.RED);
	img.drawLine(img.getWidth() - 70, img.getHeight() / 2 - 10, img.getWidth() - 50, img.getHeight() / 2, 3,
			RGBColour.RED);
	img.drawText("EV1", img.getWidth() - 70, img.getHeight() / 2 + 50, HersheyFont.ROMAN_DUPLEX, 40, RGBColour.RED);

	for (final double[] d : data) {
		img.drawPoint(new Point2dImpl(img.getWidth() / 2 - (float) d[0], img.getHeight() / 2),
				RGBColour.GREEN, 3);
	}

	return img;
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
/**
 * Construct demo
 */
public MSEREllipseFinder() {
	final MBFImage image = new MBFImage(400, 400, ColourSpace.RGB);
	final MBFImageRenderer renderer = image.createRenderer();

	image.fill(RGBColour.WHITE);
	final List<Ellipse> ellipses = new ArrayList<Ellipse>();
	ellipses.add(new Ellipse(200, 100, 100, 80, Math.PI / 4));
	ellipses.add(new Ellipse(200, 300, 50, 30, -Math.PI / 4));
	ellipses.add(new Ellipse(100, 300, 30, 50, -Math.PI / 3));

	for (final Ellipse ellipse : ellipses) {
		renderer.drawShapeFilled(ellipse, RGBColour.BLACK);
	}

	final MSERFeatureGenerator mser = new MSERFeatureGenerator(MomentFeature.class);
	final List<Component> features = mser.generateMSERs(Transforms
			.calculateIntensityNTSC(image));
	for (final Component c : features) {
		final MomentFeature feature = c.getFeature(MomentFeature.class);
		renderer.drawShape(feature.getEllipse(2), RGBColour.RED);
		renderer.drawShape(feature.getEllipse(2)
				.calculateOrientedBoundingBox(), RGBColour.GREEN);
	}
	DisplayUtilities.display(image);
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
/**
 * 	Default main
 *  @param args Command-line arguments
 */
public static void main(String args[]){
	ellipse = new Ellipse(400,400,100,50,0);
	image = new MBFImage(800,800,ColourSpace.RGB);
	frame = DisplayUtilities.display(image);
	displayUpdater = new Runnable(){
		@Override
		public void run() {
			while(true){
				DisplayUtilities.display(image,frame);
				update();
				try {
					Thread.sleep(1000/30);
				} catch (InterruptedException e) {
				}
			}
		}
		
	};
	Thread t = new Thread(displayUpdater);
	t.start();
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
void buildBinCols() {
	this.binCols = new Float[4 * 4 * 4][];
	for (int k = 0; k < 4; k++) {
		for (int j = 0; j < 4; j++) {
			for (int i = 0; i < 4; i++) {
				final float h = (float) i / 4 + (0.5f / 4);
				final float s = (float) j / 4 + (0.5f / 4);
				final float v = (float) k / 4 + (0.5f / 4);

				MBFImage img = new MBFImage(1, 1, ColourSpace.HSV);
				img.setPixel(0, 0, new Float[] { h, s, v });

				img = Transforms.HSV_TO_RGB(img);

				this.binCols[k * 4 * 4 + j * 4 + i] = img.getPixel(0, 0);
			}
		}
	}
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
@Override
public void doTutorial(MBFImage toDraw) {
	final MBFImage space = ColourSpace.convert(toDraw, ColourSpace.CIE_Lab);

	if (cluster == null)
		cluster = clusterPixels(space);

	if (cluster == null)
		return;

	final float[][] centroids = cluster.getCentroids();

	final ExactFloatAssigner assigner = new ExactFloatAssigner(cluster);

	for (int y = 0; y < space.getHeight(); y++) {
		for (int x = 0; x < space.getWidth(); x++) {
			final float[] pixel = space.getPixelNative(x, y);
			final int centroid = assigner.assign(pixel);
			space.setPixelNative(x, y, centroids[centroid]);
		}
	}

	toDraw.internalAssign(ColourSpace.convert(space, ColourSpace.RGB));
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
private static void drawMkpLine(DoubleArrayKernelPerceptron mkp) {
	final MBFImage img = new MBFImage(300, 300, ColourSpace.RGB);

	final List<double[]> sup = mkp.getSupports();
	final List<Double> weights = mkp.getWeights();
	final double bias = mkp.getBias();
	System.out.println("Bias: " + bias);
	double[] startD = null;
	double[] endD = null;

	double[] mean = new double[2];
	if (mkp instanceof MeanCenteredKernelPerceptron) {
		mean = ((MeanCenteredKernelPerceptron) mkp).getMean();
	} else if (mkp instanceof MeanCenteredProjectron) {
		mean = ((MeanCenteredProjectron) mkp).getMean();
	}
	startD = LinearVectorKernel.getPlanePoint(sup, weights, bias, -mean[0], Double.NaN);
	endD = LinearVectorKernel.getPlanePoint(sup, weights, bias, img.getWidth() - mean[0], Double.NaN);
	startD[0] += mean[0];
	startD[1] += mean[1];
	endD[0] += mean[0];
	endD[1] += mean[1];
	drawLine(img, startD, endD);
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
private static void drawPoints(Stream<IndependentPair<double[], PerceptronClass>> dataStream, Line2d line) {
	final MBFImage img = new MBFImage(300, 300, ColourSpace.RGB);

	img.drawLine(line, 3, RGBColour.BLUE);

	for (final IndependentPair<double[], PerceptronClass> pointClass : dataStream) {

		final double[] pc = pointClass.firstObject();
		final Point2dImpl point = new Point2dImpl((float) pc[0], (float) pc[1]);
		final PerceptronClass cls = pointClass.getSecondObject();
		switch (cls) {
		case TRUE:
			img.drawShapeFilled(new Circle(point, 5), RGBColour.GREEN);
			break;
		case FALSE:
			img.drawShape(new Circle(point, 5), 3, RGBColour.RED);
			break;
		case NONE:
			throw new RuntimeException("NOPE");
		}
	}
	DisplayUtilities.displayName(img, "random");
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
/**
 *
 *	@param args
 *	@throws MalformedURLException
 *	@throws IOException
 */
public static void main( final String[] args ) throws MalformedURLException, IOException
{
	final MBFImage img1 = ImageUtilities.readMBF( new URL("http://www.walkmag.co.uk/wp-content/uploads/2012/05/Wineglass_Bay-landscape.jpg") );
	final MBFImage img2 = ImageUtilities.readMBFAlpha( new URL("http://www.openimaj.org/images/OpenImaj.png") );
	final MBFImage img3 = ImageUtilities.readMBF( new URL("http://sd.keepcalm-o-matic.co.uk/i/keep-calm-and-rule-the-world-19.png") );

	final FImage alpha = img3.clone().threshold( 0.7f ).flatten().inverse().
		multiplyInplace( 0.4f ).inverse().addInplace( 0.6f );
	img3.addBand( alpha );
	img3.colourSpace = ColourSpace.RGBA;
	img2.colourSpace = ColourSpace.RGBA;

	img1.drawImage( img2, 1400, 50 );
	img1.drawImage( img3, 800, 100 );

	DisplayUtilities.display( img1 );
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
public static void main(String[] args) {
	final MBFImage image = new MBFImage(400, 400, ColourSpace.RGB);
	final MBFImageRenderer renderer = image.createRenderer();

	image.fill(RGBColour.BLACK);
	final List<Ellipse> ellipses = new ArrayList<Ellipse>();
	ellipses.add(new Ellipse(200, 100, 10, 8, Math.PI / 4));
	ellipses.add(new Ellipse(200, 300, 5, 3, -Math.PI / 4));
	ellipses.add(new Ellipse(100, 300, 3, 5, -Math.PI / 3));

	for (final Ellipse ellipse : ellipses) {
		renderer.drawShapeFilled(ellipse, RGBColour.WHITE);
	}

	final LOCKY locky = new LOCKY();
	locky.findInterestPoints(image.flatten());
	final List<EllipticInterestPointData> pts = locky.getInterestPoints();
	for (final EllipticInterestPointData pt : pts) {
		image.drawShape(pt.getEllipse(), RGBColour.RED);
	}

	DisplayUtilities.display(image);
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
/**
 * Main method
 * 
 * @param args
 */
public static void main(String[] args) {
	// Create an image
	final MBFImage image = new MBFImage(320, 70, ColourSpace.RGB);

	// Fill the image with white
	image.fill(RGBColour.WHITE);

	// Render some test into the image
	image.drawText("Hello World", 10, 60, HersheyFont.CURSIVE, 50, RGBColour.BLACK);

	// Apply a Gaussian blur
	image.processInplace(new FGaussianConvolve(2f));

	// Display the image
	DisplayUtilities.display(image);
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
/**
 * @param params
 * @return draw the plot
 */
public MBFImage draw(TernaryParams params) {

	final int padding = (Integer) params.getTyped(TernaryParams.PADDING);
	final Float[] bgColour = params.getTyped(TernaryParams.BG_COLOUR);

	final MBFImage ret = new MBFImage((int) width + padding * 2, (int) height + padding * 2, ColourSpace.RGB);
	ret.fill(bgColour);
	drawTernaryPlot(ret, params);
	drawTriangle(ret, params);
	drawBorder(ret, params);
	drawScale(ret, params);
	drawLabels(ret, params);

	return ret;
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
/**
 * Convert packed RGBA pixels in a {@link FloatBuffer} back into an
 * {@link MBFImage}. The method takes the {@link MBFImage} as an argument, and
 * will fill it accordingly. If the image argument is null, a new
 * {@link MBFImage} with the RGBA {@link ColourSpace} will be created. 
 * If the given image is the wrong size, it will be resized. If the given
 * image has less than four bands, then only these bands will be filled. 
 * Any bands above the fourth will be ignored.  
 * 
 * @param fb the {@link FloatBuffer} containing the pixels 
 * @param width the width
 * @param height the height
 * @param image the image to write to or null
 * @return the image
 */
public static MBFImage convertFromFB(FloatBuffer fb, int width, int height, MBFImage image) {
	if (image == null)
		image = new MBFImage(width, height, ColourSpace.RGBA);
	
	if (image.getWidth() != width || image.getHeight() != height)
		image.internalAssign(image.newInstance(width, height));
	
	final FImage[] bands = image.bands.toArray(new FImage[image.numBands()]);

	final int nbands = Math.min(4, image.numBands());
	final int extraBands = 4 - nbands;
	
	for (int y=0; y<height; y++) {
		for (int x=0; x<width; x++) {
			for (int b=0; b<nbands; b++) { 
				bands[b].pixels[y][x] = fb.get();
			}
			for (int b=0; b<extraBands; b++) {
				fb.get();
			}
		}
	}

	return image;
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
public static void main( String[] args ) {
	//Create an image
    MBFImage image = new MBFImage(320,70, ColourSpace.RGB);

    //Fill the image with white
    image.fill(RGBColour.WHITE);
    		        
    //Render some test into the image
    image.drawText("Hello World", 10, 60, HersheyFont.CURSIVE, 50, RGBColour.BLACK);

    //Apply a Gaussian blur
    image.processInplace(new FGaussianConvolve(2f));
    
    //Display the image
    DisplayUtilities.display(image);
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
/**
 * 	Takes a single image and detects faces, returning a map that maps
 * 	a number (the face number) to the rectangle of the detected face.
 * 
 *  @param img The image to detect faces within
 *  @param minSize The minimum size a face is allowed to be
 *  @param displayResults Whether to display the result of detection
 *  @return A list of rectangles delineating the faces
 */
public List<DetectedFace> detectFaces( FImage img,
		int minSize, boolean displayResults )
{
	try
       {
        HaarCascadeDetector hcd = new HaarCascadeDetector("haarcascade_frontalface_alt.xml");
        hcd.setMinSize( minSize );
        
           List<DetectedFace> faces = hcd.detectFaces( img );
           if( displayResults )
           {
           	MBFImage m = new MBFImage( ColourSpace.RGB, img,img,img );
           	MBFImageRenderer renderer = m.createRenderer();
           	
           	for( DetectedFace df : faces )
           		renderer.drawShape( df.getBounds(), RGBColour.RED );
           	
           	DisplayUtilities.display( m );
           }
           
           return faces;
       }
       catch( Exception e )
       {
       	System.err.println( "Could not load HAAR Cascade." );
        e.printStackTrace();
       }
	
	return null;
}
 

import org.openimaj.image.colour.ColourSpace; //导入依赖的package包/类
/**
 * Compute the disparity map between two images. If the images
 * are not in Lab colour space, then copies in lab space will
 * be created.
 * @param im1 The first image.
 * @param im2 The second image.
 * @return the disparity map between the colours in the two images.
 */
public static FImage makeDisparityMap(MBFImage im1, MBFImage im2) {
	if (im1.colourSpace != ColourSpace.CIE_Lab) {
		im1 = ColourSpace.convert(im1, ColourSpace.CIE_Lab);
	}
	
	if (im2.colourSpace != ColourSpace.CIE_Lab) {
		im2 = ColourSpace.convert(im2, ColourSpace.CIE_Lab);
	}
	
	FImage disparity = new FImage(im1.getWidth(), im1.getHeight());
	for (int y=0; y<disparity.height; y++) {
		for (int x=0; x<disparity.width; x++) {
			disparity.pixels[y][x] = calculateDeltaE(im1.getPixel(x, y), im2.getPixel(x, y));
		}
	}
	
	return disparity;
}