tests/Camera2Tests/SmartCamera/SimpleCamera/src/androidx/media/filterfw/samples/simplecamera/ImageGoodnessFilter.java - platform/frameworks/base - Git at Google

 /*
  * Copyright 2013 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 // Takes sharpness score, rates the image good if above 10, bad otherwise

 package androidx.media.filterfw.samples.simplecamera;

 import android.graphics.Bitmap;
 import android.os.AsyncTask;
 import android.util.Log;
 import android.widget.ImageView;
 import androidx.media.filterfw.Filter;
 import androidx.media.filterfw.FrameImage2D;
 import androidx.media.filterfw.FrameType;
 import androidx.media.filterfw.FrameValue;
 import androidx.media.filterfw.MffContext;
 import androidx.media.filterfw.OutputPort;
 import androidx.media.filterfw.Signature;

 public class ImageGoodnessFilter extends Filter {

     private static final String TAG = "ImageGoodnessFilter";
     private static boolean mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);

     private final static String GREAT = "Great Picture!";
     private final static String GOOD = "Good Picture!";
     private final static String OK = "Ok Picture";
     private final static String BAD = "Bad Picture";
     private final static String AWFUL = "Awful Picture";
     private final static float SMALL_SCORE_INC = 0.25f;
     private final static float BIG_SCORE_INC = 0.5f;
     private final static float LOW_VARIANCE = 0.1f;
     private final static float MEDIUM_VARIANCE = 10;
     private final static float HIGH_VARIANCE = 100;
     private float sharpnessMean = 0;
     private float sharpnessVar = 0;
     private float underExposureMean = 0;
     private float underExposureVar = 0;
     private float overExposureMean = 0;
     private float overExposureVar = 0;
     private float contrastMean = 0;
     private float contrastVar = 0;
     private float colorfulnessMean = 0;
     private float colorfulnessVar = 0;
     private float brightnessMean = 0;
     private float brightnessVar = 0;

     private float motionMean = 0;
     private float scoreMean = 0;
     private static final float DECAY = 0.03f;
     /**
      * @param context
      * @param name
      */
     public ImageGoodnessFilter(MffContext context, String name) {
         super(context, name);
     }

     @Override
     public Signature getSignature() {
         FrameType floatT = FrameType.single(float.class);
         FrameType imageIn = FrameType.image2D(FrameType.ELEMENT_RGBA8888, FrameType.READ_GPU);

         return new Signature()
                 .addInputPort("sharpness", Signature.PORT_REQUIRED, floatT)
                 .addInputPort("overExposure", Signature.PORT_REQUIRED, floatT)
                 .addInputPort("underExposure", Signature.PORT_REQUIRED, floatT)
                 .addInputPort("colorfulness", Signature.PORT_REQUIRED, floatT)
                 .addInputPort("contrastRating", Signature.PORT_REQUIRED, floatT)
                 .addInputPort("motionValues", Signature.PORT_REQUIRED, FrameType.array(float.class))
                 .addInputPort("brightness", Signature.PORT_REQUIRED, floatT)
                 .addInputPort("capturing", Signature.PORT_REQUIRED, FrameType.single(boolean.class))
                 .addInputPort("image", Signature.PORT_REQUIRED, imageIn)
                 .addOutputPort("goodOrBadPic", Signature.PORT_REQUIRED,
                         FrameType.single(String.class))
                 .addOutputPort("score", Signature.PORT_OPTIONAL, floatT)
                 .disallowOtherPorts();
     }

     /**
      * @see androidx.media.filterfw.Filter#onProcess()
      */
     @Override
     protected void onProcess() {
         FrameValue sharpnessFrameValue =
                 getConnectedInputPort("sharpness").pullFrame().asFrameValue();
         float sharpness = ((Float)sharpnessFrameValue.getValue()).floatValue();

         FrameValue overExposureFrameValue =
                 getConnectedInputPort("overExposure").pullFrame().asFrameValue();
         float overExposure = ((Float)overExposureFrameValue.getValue()).floatValue();

         FrameValue underExposureFrameValue =
                 getConnectedInputPort("underExposure").pullFrame().asFrameValue();
         float underExposure = ((Float)underExposureFrameValue.getValue()).floatValue();

         FrameValue colorfulnessFrameValue =
                 getConnectedInputPort("colorfulness").pullFrame().asFrameValue();
         float colorfulness = ((Float)colorfulnessFrameValue.getValue()).floatValue();

         FrameValue contrastRatingFrameValue =
                 getConnectedInputPort("contrastRating").pullFrame().asFrameValue();
         float contrastRating = ((Float)contrastRatingFrameValue.getValue()).floatValue();

         FrameValue brightnessFrameValue =
                 getConnectedInputPort("brightness").pullFrame().asFrameValue();
         float brightness = ((Float)brightnessFrameValue.getValue()).floatValue();

         FrameValue motionValuesFrameValue =
                 getConnectedInputPort("motionValues").pullFrame().asFrameValue();
         float[] motionValues = (float[]) motionValuesFrameValue.getValue();


         float vectorAccel = (float) Math.sqrt(Math.pow(motionValues[0], 2) +
                 Math.pow(motionValues[1], 2) + Math.pow(motionValues[2], 2));
         String outStr;

         FrameValue capturingFrameValue =
                 getConnectedInputPort("capturing").pullFrame().asFrameValue();
         boolean capturing = (Boolean) capturingFrameValue.getValue();

         FrameImage2D inputImage = getConnectedInputPort("image").pullFrame().asFrameImage2D();


         // TODO: get rid of magic numbers
         float score = 0.0f;
         score = computePictureScore(vectorAccel, sharpness, underExposure, overExposure,
                     contrastRating, colorfulness, brightness);
         if (scoreMean == 0) scoreMean = score;
         else scoreMean = scoreMean * (1 - DECAY) + score * DECAY;

         if (motionMean == 0) motionMean = vectorAccel;
         else motionMean = motionMean * (1 - DECAY) + vectorAccel * DECAY;

         float classifierScore = classifierComputeScore(vectorAccel, sharpness, underExposure,
                 colorfulness, contrastRating, score);

 //        Log.v(TAG, "ClassifierScore:: " + classifierScore);
         final float GREAT_SCORE = 3.5f;
         final float GOOD_SCORE = 2.5f;
         final float OK_SCORE = 1.5f;
         final float BAD_SCORE = 0.5f;

         if (score >= GREAT_SCORE) {
             outStr = GREAT;
         } else if (score >= GOOD_SCORE) {
             outStr = GOOD;
         } else if (score >= OK_SCORE) {
             outStr = OK;
         } else if (score >= BAD_SCORE) {
             outStr = BAD;
         } else {
             outStr = AWFUL;
         }

         if(capturing) {
             if (outStr.equals(GREAT)) {
                 // take a picture
                 Bitmap bitmap = inputImage.toBitmap();

                 new AsyncOperation().execute(bitmap);
                 final float RESET_FEATURES = 0.01f;
                 sharpnessMean = RESET_FEATURES;
                 underExposureMean = RESET_FEATURES;
                 overExposureMean = RESET_FEATURES;
                 contrastMean = RESET_FEATURES;
                 colorfulnessMean = RESET_FEATURES;
                 brightnessMean = RESET_FEATURES;
             }
         }

         OutputPort outPort = getConnectedOutputPort("goodOrBadPic");
         FrameValue stringFrame = outPort.fetchAvailableFrame(null).asFrameValue();
         stringFrame.setValue(outStr);
         outPort.pushFrame(stringFrame);

         OutputPort scoreOutPort = getConnectedOutputPort("score");
         FrameValue scoreFrame = scoreOutPort.fetchAvailableFrame(null).asFrameValue();
         scoreFrame.setValue(score);
         scoreOutPort.pushFrame(scoreFrame);

     }

     private class AsyncOperation extends AsyncTask<Bitmap, Void, String> {
         private Bitmap b;
         protected void onPostExecute(String result) {
             ImageView view = SmartCamera.getImageView();
             view.setImageBitmap(b);
         }

         @Override
         protected String doInBackground(Bitmap... params) {
             // TODO Auto-generated method stub
             b = params[0];
             return null;
         }

     }
     // Returns a number between -1 and 1
     private float classifierComputeScore(float vectorAccel, float sharpness, float underExposure,
            float colorfulness, float contrast, float score) {
         float result = (-0.0223f * sharpness + -0.0563f * underExposure + 0.0137f * colorfulness
                 + 0.3102f * contrast + 0.0314f * vectorAccel + -0.0094f * score + 0.0227f *
                 sharpnessMean + 0.0459f * underExposureMean + -0.3934f * contrastMean +
                 -0.0697f * motionMean + 0.0091f * scoreMean + -0.0152f);
         return result;
     }

     // Returns a number between -1 and 4 representing the score for this picture
     private float computePictureScore(float vector_accel, float sharpness,
             float underExposure, float overExposure, float contrastRating, float colorfulness,
             float brightness) {
         final float ACCELERATION_THRESHOLD_VERY_STEADY = 0.1f;
         final float ACCELERATION_THRESHOLD_STEADY = 0.3f;
         final float ACCELERATION_THRESHOLD_MOTION = 2f;

         float score = 0.0f;
         if (vector_accel > ACCELERATION_THRESHOLD_MOTION) {
             score -= (BIG_SCORE_INC + BIG_SCORE_INC); // set score to -1, bad pic
         } else if (vector_accel > ACCELERATION_THRESHOLD_STEADY) {
             score -= BIG_SCORE_INC;
             score = subComputeScore(sharpness, underExposure, overExposure, contrastRating,
                     colorfulness, brightness, score);
         } else if (vector_accel < ACCELERATION_THRESHOLD_VERY_STEADY) {
             score += BIG_SCORE_INC;
             score = subComputeScore(sharpness, underExposure, overExposure, contrastRating,
                     colorfulness, brightness, score);
         } else {
             score = subComputeScore(sharpness, underExposure, overExposure, contrastRating,
                     colorfulness, brightness, score);
         }
         return score;
     }

     // Changes the score by at most +/- 3.5
     private float subComputeScore(float sharpness, float underExposure, float overExposure,
                 float contrastRating, float colorfulness, float brightness, float score) {
         // The score methods return values -0.5 to 0.5
         final float SHARPNESS_WEIGHT = 2;
         score += SHARPNESS_WEIGHT * sharpnessScore(sharpness);
         score += underExposureScore(underExposure);
         score += overExposureScore(overExposure);
         score += contrastScore(contrastRating);
         score += colorfulnessScore(colorfulness);
         score += brightnessScore(brightness);
         return score;
     }

     private float sharpnessScore(float sharpness) {
         if (sharpnessMean == 0) {
             sharpnessMean = sharpness;
             sharpnessVar = 0;
             return 0;
         } else {
             sharpnessMean = sharpnessMean * (1 - DECAY) + sharpness * DECAY;
             sharpnessVar = sharpnessVar * (1 - DECAY) + (sharpness - sharpnessMean) *
                     (sharpness - sharpnessMean) * DECAY;
             if (sharpnessVar < LOW_VARIANCE) {
                 return BIG_SCORE_INC;
             } else if (sharpness < sharpnessMean && sharpnessVar > MEDIUM_VARIANCE) {
                 return -BIG_SCORE_INC;
             } else if (sharpness < sharpnessMean) {
                 return -SMALL_SCORE_INC;
             } else if (sharpness > sharpnessMean && sharpnessVar > HIGH_VARIANCE) {
                 return 0;
             } else if (sharpness > sharpnessMean && sharpnessVar > MEDIUM_VARIANCE) {
                 return SMALL_SCORE_INC;
             } else  {
                 return BIG_SCORE_INC; // low variance, sharpness above the mean
             }
         }
     }

     private float underExposureScore(float underExposure) {
         if (underExposureMean == 0) {
             underExposureMean = underExposure;
             underExposureVar = 0;
             return 0;
         } else {
             underExposureMean = underExposureMean * (1 - DECAY) + underExposure * DECAY;
             underExposureVar = underExposureVar * (1 - DECAY) + (underExposure - underExposureMean)
                     * (underExposure - underExposureMean) * DECAY;
             if (underExposureVar < LOW_VARIANCE) {
                 return BIG_SCORE_INC;
             } else if (underExposure > underExposureMean && underExposureVar > MEDIUM_VARIANCE) {
                 return -BIG_SCORE_INC;
             } else if (underExposure > underExposureMean) {
                 return -SMALL_SCORE_INC;
             } else if (underExposure < underExposureMean && underExposureVar > HIGH_VARIANCE) {
                 return 0;
             } else if (underExposure < underExposureMean && underExposureVar > MEDIUM_VARIANCE) {
                 return SMALL_SCORE_INC;
             } else {
                 return BIG_SCORE_INC; // low variance, underExposure below the mean
             }
         }
     }

     private float overExposureScore(float overExposure) {
         if (overExposureMean == 0) {
             overExposureMean = overExposure;
             overExposureVar = 0;
             return 0;
         } else {
             overExposureMean = overExposureMean * (1 - DECAY) + overExposure * DECAY;
             overExposureVar = overExposureVar * (1 - DECAY) + (overExposure - overExposureMean) *
                     (overExposure - overExposureMean) * DECAY;
             if (overExposureVar < LOW_VARIANCE) {
                 return BIG_SCORE_INC;
             } else if (overExposure > overExposureMean && overExposureVar > MEDIUM_VARIANCE) {
                 return -BIG_SCORE_INC;
             } else if (overExposure > overExposureMean) {
                 return -SMALL_SCORE_INC;
             } else if (overExposure < overExposureMean && overExposureVar > HIGH_VARIANCE) {
                 return 0;
             } else if (overExposure < overExposureMean && overExposureVar > MEDIUM_VARIANCE) {
                 return SMALL_SCORE_INC;
             } else {
                 return BIG_SCORE_INC; // low variance, overExposure below the mean
             }
         }
     }

     private float contrastScore(float contrast) {
         if (contrastMean == 0) {
             contrastMean = contrast;
             contrastVar = 0;
             return 0;
         } else {
             contrastMean = contrastMean * (1 - DECAY) + contrast * DECAY;
             contrastVar = contrastVar * (1 - DECAY) + (contrast - contrastMean) *
                     (contrast - contrastMean) * DECAY;
             if (contrastVar < LOW_VARIANCE) {
                 return BIG_SCORE_INC;
             } else if (contrast < contrastMean && contrastVar > MEDIUM_VARIANCE) {
                 return -BIG_SCORE_INC;
             } else if (contrast < contrastMean) {
                 return -SMALL_SCORE_INC;
             } else if (contrast > contrastMean && contrastVar > 100) {
                 return 0;
             } else if (contrast > contrastMean && contrastVar > MEDIUM_VARIANCE) {
                 return SMALL_SCORE_INC;
             } else {
                 return BIG_SCORE_INC; // low variance, contrast above the mean
             }
         }
     }

     private float colorfulnessScore(float colorfulness) {
         if (colorfulnessMean == 0) {
             colorfulnessMean = colorfulness;
             colorfulnessVar = 0;
             return 0;
         } else {
             colorfulnessMean = colorfulnessMean * (1 - DECAY) + colorfulness * DECAY;
             colorfulnessVar = colorfulnessVar * (1 - DECAY) + (colorfulness - colorfulnessMean) *
                     (colorfulness - colorfulnessMean) * DECAY;
             if (colorfulnessVar < LOW_VARIANCE) {
                 return BIG_SCORE_INC;
             } else if (colorfulness < colorfulnessMean && colorfulnessVar > MEDIUM_VARIANCE) {
                 return -BIG_SCORE_INC;
             } else if (colorfulness < colorfulnessMean) {
                 return -SMALL_SCORE_INC;
             } else if (colorfulness > colorfulnessMean && colorfulnessVar > 100) {
                 return 0;
             } else if (colorfulness > colorfulnessMean && colorfulnessVar > MEDIUM_VARIANCE) {
                 return SMALL_SCORE_INC;
             } else {
                 return BIG_SCORE_INC; // low variance, colorfulness above the mean
             }
         }
     }

     private float brightnessScore(float brightness) {
         if (brightnessMean == 0) {
             brightnessMean = brightness;
             brightnessVar = 0;
             return 0;
         } else {
             brightnessMean = brightnessMean * (1 - DECAY) + brightness * DECAY;
             brightnessVar = brightnessVar * (1 - DECAY) + (brightness - brightnessMean) *
                     (brightness - brightnessMean) * DECAY;
             if (brightnessVar < LOW_VARIANCE) {
                 return BIG_SCORE_INC;
             } else if (brightness < brightnessMean && brightnessVar > MEDIUM_VARIANCE) {
                 return -BIG_SCORE_INC;
             } else if (brightness < brightnessMean) {
                 return -SMALL_SCORE_INC;
             } else if (brightness > brightnessMean && brightnessVar > 100) {
                 return 0;
             } else if (brightness > brightnessMean && brightnessVar > MEDIUM_VARIANCE) {
                 return SMALL_SCORE_INC;
             } else {
                 return BIG_SCORE_INC; // low variance, brightness above the mean
             }
         }
     }
 }
	/*
	* Copyright 2013 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	// Takes sharpness score, rates the image good if above 10, bad otherwise

	package androidx.media.filterfw.samples.simplecamera;

	import android.graphics.Bitmap;
	import android.os.AsyncTask;
	import android.util.Log;
	import android.widget.ImageView;
	import androidx.media.filterfw.Filter;
	import androidx.media.filterfw.FrameImage2D;
	import androidx.media.filterfw.FrameType;
	import androidx.media.filterfw.FrameValue;
	import androidx.media.filterfw.MffContext;
	import androidx.media.filterfw.OutputPort;
	import androidx.media.filterfw.Signature;

	public class ImageGoodnessFilter extends Filter {

	private static final String TAG = "ImageGoodnessFilter";
	private static boolean mLogVerbose = Log.isLoggable(TAG, Log.VERBOSE);

	private final static String GREAT = "Great Picture!";
	private final static String GOOD = "Good Picture!";
	private final static String OK = "Ok Picture";
	private final static String BAD = "Bad Picture";
	private final static String AWFUL = "Awful Picture";
	private final static float SMALL_SCORE_INC = 0.25f;
	private final static float BIG_SCORE_INC = 0.5f;
	private final static float LOW_VARIANCE = 0.1f;
	private final static float MEDIUM_VARIANCE = 10;
	private final static float HIGH_VARIANCE = 100;
	private float sharpnessMean = 0;
	private float sharpnessVar = 0;
	private float underExposureMean = 0;
	private float underExposureVar = 0;
	private float overExposureMean = 0;
	private float overExposureVar = 0;
	private float contrastMean = 0;
	private float contrastVar = 0;
	private float colorfulnessMean = 0;
	private float colorfulnessVar = 0;
	private float brightnessMean = 0;
	private float brightnessVar = 0;

	private float motionMean = 0;
	private float scoreMean = 0;
	private static final float DECAY = 0.03f;
	/**
	* @param context
	* @param name
	*/
	public ImageGoodnessFilter(MffContext context, String name) {
	super(context, name);
	}

	@Override
	public Signature getSignature() {
	FrameType floatT = FrameType.single(float.class);
	FrameType imageIn = FrameType.image2D(FrameType.ELEMENT_RGBA8888, FrameType.READ_GPU);

	return new Signature()
	.addInputPort("sharpness", Signature.PORT_REQUIRED, floatT)
	.addInputPort("overExposure", Signature.PORT_REQUIRED, floatT)
	.addInputPort("underExposure", Signature.PORT_REQUIRED, floatT)
	.addInputPort("colorfulness", Signature.PORT_REQUIRED, floatT)
	.addInputPort("contrastRating", Signature.PORT_REQUIRED, floatT)
	.addInputPort("motionValues", Signature.PORT_REQUIRED, FrameType.array(float.class))
	.addInputPort("brightness", Signature.PORT_REQUIRED, floatT)
	.addInputPort("capturing", Signature.PORT_REQUIRED, FrameType.single(boolean.class))
	.addInputPort("image", Signature.PORT_REQUIRED, imageIn)
	.addOutputPort("goodOrBadPic", Signature.PORT_REQUIRED,
	FrameType.single(String.class))
	.addOutputPort("score", Signature.PORT_OPTIONAL, floatT)
	.disallowOtherPorts();
	}

	/**
	* @see androidx.media.filterfw.Filter#onProcess()
	*/
	@Override
	protected void onProcess() {
	FrameValue sharpnessFrameValue =
	getConnectedInputPort("sharpness").pullFrame().asFrameValue();
	float sharpness = ((Float)sharpnessFrameValue.getValue()).floatValue();

	FrameValue overExposureFrameValue =
	getConnectedInputPort("overExposure").pullFrame().asFrameValue();
	float overExposure = ((Float)overExposureFrameValue.getValue()).floatValue();

	FrameValue underExposureFrameValue =
	getConnectedInputPort("underExposure").pullFrame().asFrameValue();
	float underExposure = ((Float)underExposureFrameValue.getValue()).floatValue();

	FrameValue colorfulnessFrameValue =
	getConnectedInputPort("colorfulness").pullFrame().asFrameValue();
	float colorfulness = ((Float)colorfulnessFrameValue.getValue()).floatValue();

	FrameValue contrastRatingFrameValue =
	getConnectedInputPort("contrastRating").pullFrame().asFrameValue();
	float contrastRating = ((Float)contrastRatingFrameValue.getValue()).floatValue();

	FrameValue brightnessFrameValue =
	getConnectedInputPort("brightness").pullFrame().asFrameValue();
	float brightness = ((Float)brightnessFrameValue.getValue()).floatValue();

	FrameValue motionValuesFrameValue =
	getConnectedInputPort("motionValues").pullFrame().asFrameValue();
	float[] motionValues = (float[]) motionValuesFrameValue.getValue();


	float vectorAccel = (float) Math.sqrt(Math.pow(motionValues[0], 2) +
	Math.pow(motionValues[1], 2) + Math.pow(motionValues[2], 2));
	String outStr;

	FrameValue capturingFrameValue =
	getConnectedInputPort("capturing").pullFrame().asFrameValue();
	boolean capturing = (Boolean) capturingFrameValue.getValue();

	FrameImage2D inputImage = getConnectedInputPort("image").pullFrame().asFrameImage2D();


	// TODO: get rid of magic numbers
	float score = 0.0f;
	score = computePictureScore(vectorAccel, sharpness, underExposure, overExposure,
	contrastRating, colorfulness, brightness);
	if (scoreMean == 0) scoreMean = score;
	else scoreMean = scoreMean * (1 - DECAY) + score * DECAY;

	if (motionMean == 0) motionMean = vectorAccel;
	else motionMean = motionMean * (1 - DECAY) + vectorAccel * DECAY;

	float classifierScore = classifierComputeScore(vectorAccel, sharpness, underExposure,
	colorfulness, contrastRating, score);

	// Log.v(TAG, "ClassifierScore:: " + classifierScore);
	final float GREAT_SCORE = 3.5f;
	final float GOOD_SCORE = 2.5f;
	final float OK_SCORE = 1.5f;
	final float BAD_SCORE = 0.5f;

	if (score >= GREAT_SCORE) {
	outStr = GREAT;
	} else if (score >= GOOD_SCORE) {
	outStr = GOOD;
	} else if (score >= OK_SCORE) {
	outStr = OK;
	} else if (score >= BAD_SCORE) {
	outStr = BAD;
	} else {
	outStr = AWFUL;
	}

	if(capturing) {
	if (outStr.equals(GREAT)) {
	// take a picture
	Bitmap bitmap = inputImage.toBitmap();

	new AsyncOperation().execute(bitmap);
	final float RESET_FEATURES = 0.01f;
	sharpnessMean = RESET_FEATURES;
	underExposureMean = RESET_FEATURES;
	overExposureMean = RESET_FEATURES;
	contrastMean = RESET_FEATURES;
	colorfulnessMean = RESET_FEATURES;
	brightnessMean = RESET_FEATURES;
	}
	}

	OutputPort outPort = getConnectedOutputPort("goodOrBadPic");
	FrameValue stringFrame = outPort.fetchAvailableFrame(null).asFrameValue();
	stringFrame.setValue(outStr);
	outPort.pushFrame(stringFrame);

	OutputPort scoreOutPort = getConnectedOutputPort("score");
	FrameValue scoreFrame = scoreOutPort.fetchAvailableFrame(null).asFrameValue();
	scoreFrame.setValue(score);
	scoreOutPort.pushFrame(scoreFrame);

	}

	private class AsyncOperation extends AsyncTask<Bitmap, Void, String> {
	private Bitmap b;
	protected void onPostExecute(String result) {
	ImageView view = SmartCamera.getImageView();
	view.setImageBitmap(b);
	}

	@Override
	protected String doInBackground(Bitmap... params) {
	// TODO Auto-generated method stub
	b = params[0];
	return null;
	}

	}
	// Returns a number between -1 and 1
	private float classifierComputeScore(float vectorAccel, float sharpness, float underExposure,
	float colorfulness, float contrast, float score) {
	float result = (-0.0223f * sharpness + -0.0563f * underExposure + 0.0137f * colorfulness
	+ 0.3102f * contrast + 0.0314f * vectorAccel + -0.0094f * score + 0.0227f *
	sharpnessMean + 0.0459f * underExposureMean + -0.3934f * contrastMean +
	-0.0697f * motionMean + 0.0091f * scoreMean + -0.0152f);
	return result;
	}

	// Returns a number between -1 and 4 representing the score for this picture
	private float computePictureScore(float vector_accel, float sharpness,
	float underExposure, float overExposure, float contrastRating, float colorfulness,
	float brightness) {
	final float ACCELERATION_THRESHOLD_VERY_STEADY = 0.1f;
	final float ACCELERATION_THRESHOLD_STEADY = 0.3f;
	final float ACCELERATION_THRESHOLD_MOTION = 2f;

	float score = 0.0f;
	if (vector_accel > ACCELERATION_THRESHOLD_MOTION) {
	score -= (BIG_SCORE_INC + BIG_SCORE_INC); // set score to -1, bad pic
	} else if (vector_accel > ACCELERATION_THRESHOLD_STEADY) {
	score -= BIG_SCORE_INC;
	score = subComputeScore(sharpness, underExposure, overExposure, contrastRating,
	colorfulness, brightness, score);
	} else if (vector_accel < ACCELERATION_THRESHOLD_VERY_STEADY) {
	score += BIG_SCORE_INC;
	score = subComputeScore(sharpness, underExposure, overExposure, contrastRating,
	colorfulness, brightness, score);
	} else {
	score = subComputeScore(sharpness, underExposure, overExposure, contrastRating,
	colorfulness, brightness, score);
	}
	return score;
	}

	// Changes the score by at most +/- 3.5
	private float subComputeScore(float sharpness, float underExposure, float overExposure,
	float contrastRating, float colorfulness, float brightness, float score) {
	// The score methods return values -0.5 to 0.5
	final float SHARPNESS_WEIGHT = 2;
	score += SHARPNESS_WEIGHT * sharpnessScore(sharpness);
	score += underExposureScore(underExposure);
	score += overExposureScore(overExposure);
	score += contrastScore(contrastRating);
	score += colorfulnessScore(colorfulness);
	score += brightnessScore(brightness);
	return score;
	}

	private float sharpnessScore(float sharpness) {
	if (sharpnessMean == 0) {
	sharpnessMean = sharpness;
	sharpnessVar = 0;
	return 0;
	} else {
	sharpnessMean = sharpnessMean * (1 - DECAY) + sharpness * DECAY;
	sharpnessVar = sharpnessVar * (1 - DECAY) + (sharpness - sharpnessMean) *
	(sharpness - sharpnessMean) * DECAY;
	if (sharpnessVar < LOW_VARIANCE) {
	return BIG_SCORE_INC;
	} else if (sharpness < sharpnessMean && sharpnessVar > MEDIUM_VARIANCE) {
	return -BIG_SCORE_INC;
	} else if (sharpness < sharpnessMean) {
	return -SMALL_SCORE_INC;
	} else if (sharpness > sharpnessMean && sharpnessVar > HIGH_VARIANCE) {
	return 0;
	} else if (sharpness > sharpnessMean && sharpnessVar > MEDIUM_VARIANCE) {
	return SMALL_SCORE_INC;
	} else {
	return BIG_SCORE_INC; // low variance, sharpness above the mean
	}
	}
	}

	private float underExposureScore(float underExposure) {
	if (underExposureMean == 0) {
	underExposureMean = underExposure;
	underExposureVar = 0;
	return 0;
	} else {
	underExposureMean = underExposureMean * (1 - DECAY) + underExposure * DECAY;
	underExposureVar = underExposureVar * (1 - DECAY) + (underExposure - underExposureMean)
	* (underExposure - underExposureMean) * DECAY;
	if (underExposureVar < LOW_VARIANCE) {
	return BIG_SCORE_INC;
	} else if (underExposure > underExposureMean && underExposureVar > MEDIUM_VARIANCE) {
	return -BIG_SCORE_INC;
	} else if (underExposure > underExposureMean) {
	return -SMALL_SCORE_INC;
	} else if (underExposure < underExposureMean && underExposureVar > HIGH_VARIANCE) {
	return 0;
	} else if (underExposure < underExposureMean && underExposureVar > MEDIUM_VARIANCE) {
	return SMALL_SCORE_INC;
	} else {
	return BIG_SCORE_INC; // low variance, underExposure below the mean
	}
	}
	}

	private float overExposureScore(float overExposure) {
	if (overExposureMean == 0) {
	overExposureMean = overExposure;
	overExposureVar = 0;
	return 0;
	} else {
	overExposureMean = overExposureMean * (1 - DECAY) + overExposure * DECAY;
	overExposureVar = overExposureVar * (1 - DECAY) + (overExposure - overExposureMean) *
	(overExposure - overExposureMean) * DECAY;
	if (overExposureVar < LOW_VARIANCE) {
	return BIG_SCORE_INC;
	} else if (overExposure > overExposureMean && overExposureVar > MEDIUM_VARIANCE) {
	return -BIG_SCORE_INC;
	} else if (overExposure > overExposureMean) {
	return -SMALL_SCORE_INC;
	} else if (overExposure < overExposureMean && overExposureVar > HIGH_VARIANCE) {
	return 0;
	} else if (overExposure < overExposureMean && overExposureVar > MEDIUM_VARIANCE) {
	return SMALL_SCORE_INC;
	} else {
	return BIG_SCORE_INC; // low variance, overExposure below the mean
	}
	}
	}

	private float contrastScore(float contrast) {
	if (contrastMean == 0) {
	contrastMean = contrast;
	contrastVar = 0;
	return 0;
	} else {
	contrastMean = contrastMean * (1 - DECAY) + contrast * DECAY;
	contrastVar = contrastVar * (1 - DECAY) + (contrast - contrastMean) *
	(contrast - contrastMean) * DECAY;
	if (contrastVar < LOW_VARIANCE) {
	return BIG_SCORE_INC;
	} else if (contrast < contrastMean && contrastVar > MEDIUM_VARIANCE) {
	return -BIG_SCORE_INC;
	} else if (contrast < contrastMean) {
	return -SMALL_SCORE_INC;
	} else if (contrast > contrastMean && contrastVar > 100) {
	return 0;
	} else if (contrast > contrastMean && contrastVar > MEDIUM_VARIANCE) {
	return SMALL_SCORE_INC;
	} else {
	return BIG_SCORE_INC; // low variance, contrast above the mean
	}
	}
	}

	private float colorfulnessScore(float colorfulness) {
	if (colorfulnessMean == 0) {
	colorfulnessMean = colorfulness;
	colorfulnessVar = 0;
	return 0;
	} else {
	colorfulnessMean = colorfulnessMean * (1 - DECAY) + colorfulness * DECAY;
	colorfulnessVar = colorfulnessVar * (1 - DECAY) + (colorfulness - colorfulnessMean) *
	(colorfulness - colorfulnessMean) * DECAY;
	if (colorfulnessVar < LOW_VARIANCE) {
	return BIG_SCORE_INC;
	} else if (colorfulness < colorfulnessMean && colorfulnessVar > MEDIUM_VARIANCE) {
	return -BIG_SCORE_INC;
	} else if (colorfulness < colorfulnessMean) {
	return -SMALL_SCORE_INC;
	} else if (colorfulness > colorfulnessMean && colorfulnessVar > 100) {
	return 0;
	} else if (colorfulness > colorfulnessMean && colorfulnessVar > MEDIUM_VARIANCE) {
	return SMALL_SCORE_INC;
	} else {
	return BIG_SCORE_INC; // low variance, colorfulness above the mean
	}
	}
	}

	private float brightnessScore(float brightness) {
	if (brightnessMean == 0) {
	brightnessMean = brightness;
	brightnessVar = 0;
	return 0;
	} else {
	brightnessMean = brightnessMean * (1 - DECAY) + brightness * DECAY;
	brightnessVar = brightnessVar * (1 - DECAY) + (brightness - brightnessMean) *
	(brightness - brightnessMean) * DECAY;
	if (brightnessVar < LOW_VARIANCE) {
	return BIG_SCORE_INC;
	} else if (brightness < brightnessMean && brightnessVar > MEDIUM_VARIANCE) {
	return -BIG_SCORE_INC;
	} else if (brightness < brightnessMean) {
	return -SMALL_SCORE_INC;
	} else if (brightness > brightnessMean && brightnessVar > 100) {
	return 0;
	} else if (brightness > brightnessMean && brightnessVar > MEDIUM_VARIANCE) {
	return SMALL_SCORE_INC;
	} else {
	return BIG_SCORE_INC; // low variance, brightness above the mean
	}
	}
	}
	}