am 7390e049: am 77414216: Merge "color blindness enhancement" into klp-dev (8e84e294) · Commits · e / os / android_frameworks_native

services/surfaceflinger/Android.mk

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -17,6 +17,7 @@ LOCAL_SRC_FILES:= \
	DisplayHardware/HWComposer.cpp \		DisplayHardware/HWComposer.cpp \
	DisplayHardware/PowerHAL.cpp \		DisplayHardware/PowerHAL.cpp \
	DisplayHardware/VirtualDisplaySurface.cpp \		DisplayHardware/VirtualDisplaySurface.cpp \
			Effects/Daltonizer.cpp \
	EventLog/EventLogTags.logtags \		EventLog/EventLogTags.logtags \
	EventLog/EventLog.cpp \		EventLog/EventLog.cpp \
	RenderEngine/Description.cpp \		RenderEngine/Description.cpp \

services/surfaceflinger/Effects/Daltonizer.cpp

0 → 100644

+183 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* 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.
			*/

			#include "Daltonizer.h"
			#include <ui/mat4.h>

			namespace android {

			Daltonizer::Daltonizer() :
			mType(deuteranomaly), mMode(simulation), mDirty(true) {
			}

			Daltonizer::~Daltonizer() {
			}

			void Daltonizer::setType(Daltonizer::ColorBlindnessTypes type) {
			if (type != mType) {
			mDirty = true;
			mType = type;
			}
			}

			void Daltonizer::setMode(Daltonizer::Mode mode) {
			if (mode != mMode) {
			mDirty = true;
			mMode = mode;
			}
			}

			const mat4& Daltonizer::operator()() {
			if (mDirty) {
			mDirty = false;
			update();
			}
			return mColorTransform;
			}

			void Daltonizer::update() {
			// converts a linear RGB color to the XYZ space
			const mat4 rgb2xyz( 0.4124, 0.2126, 0.0193, 0,
			0.3576, 0.7152, 0.1192, 0,
			0.1805, 0.0722, 0.9505, 0,
			0 , 0 , 0 , 1);

			// converts a XYZ color to the LMS space.
			const mat4 xyz2lms( 0.7328,-0.7036, 0.0030, 0,
			0.4296, 1.6975, 0.0136, 0,
			-0.1624, 0.0061, 0.9834, 0,
			0 , 0 , 0 , 1);

			// Direct conversion from linear RGB to LMS
			const mat4 rgb2lms(xyz2lms*rgb2xyz);

			// And back from LMS to linear RGB
			const mat4 lms2rgb(inverse(rgb2lms));

			// To simulate color blindness we need to "remove" the data lost by the absence of
			// a cone. This cannot be done by just zeroing out the corresponding LMS component
			// because it would create a color outside of the RGB gammut.
			// Instead we project the color along the axis of the missing component onto a plane
			// within the RGB gammut:
			// - since the projection happens along the axis of the missing component, a
			// color blind viewer perceives the projected color the same.
			// - We use the plane defined by 3 points in LMS space: black, white and
			// blue and red for protanopia/deuteranopia and tritanopia respectively.

			// LMS space red
			const vec3& lms_r(rgb2lms[0].rgb);
			// LMS space blue
			const vec3& lms_b(rgb2lms[2].rgb);
			// LMS space white
			const vec3 lms_w((rgb2lms * vec4(1)).rgb);

			// To find the planes we solve the aL + bM + c*S = 0 equation for the LMS values
			// of the three known points. This equation is trivially solved, and has for
			// solution the following cross-products:
			const vec3 p0 = cross(lms_w, lms_b); // protanopia/deuteranopia
			const vec3 p1 = cross(lms_w, lms_r); // tritanopia

			// The following 3 matrices perform the projection of a LMS color onto the given plane
			// along the selected axis

			// projection for protanopia (L = 0)
			const mat4 lms2lmsp( 0.0000, 0.0000, 0.0000, 0,
			-p0.y / p0.x, 1.0000, 0.0000, 0,
			-p0.z / p0.x, 0.0000, 1.0000, 0,
			0 , 0 , 0 , 1);

			// projection for deuteranopia (M = 0)
			const mat4 lms2lmsd( 1.0000, -p0.x / p0.y, 0.0000, 0,
			0.0000, 0.0000, 0.0000, 0,
			0.0000, -p0.z / p0.y, 1.0000, 0,
			0 , 0 , 0 , 1);

			// projection for tritanopia (S = 0)
			const mat4 lms2lmst( 1.0000, 0.0000, -p1.x / p1.z, 0,
			0.0000, 1.0000, -p1.y / p1.z, 0,
			0.0000, 0.0000, 0.0000, 0,
			0 , 0 , 0 , 1);

			// We will calculate the error between the color and the color viewed by
			// a color blind user and "spread" this error onto the healthy cones.
			// The matrices below perform this last step and have been chosen arbitrarily.

			// The amount of correction can be adjusted here.

			// error spread for protanopia
			const mat4 errp( 1.0, 0.7, 0.7, 0,
			0.0, 1.0, 0.0, 0,
			0.0, 0.0, 1.0, 0,
			0, 0, 0, 1);

			// error spread for deuteranopia
			const mat4 errd( 1.0, 0.0, 0.0, 0,
			0.7, 1.0, 0.7, 0,
			0.0, 0.0, 1.0, 0,
			0, 0, 0, 1);

			// error spread for tritanopia
			const mat4 errt( 1.0, 0.0, 0.0, 0,
			0.0, 1.0, 0.0, 0,
			0.7, 0.7, 1.0, 0,
			0, 0, 0, 1);

			const mat4 identity;

			// And the magic happens here...
			// We construct the matrix that will perform the whole correction.

			// simulation: type of color blindness to simulate:
			// set to either lms2lmsp, lms2lmsd, lms2lmst
			mat4 simulation;

			// correction: type of color blindness correction (should match the simulation above):
			// set to identity, errp, errd, errt ([0] for simulation only)
			mat4 correction(0);

			// control: simulation post-correction (used for debugging):
			// set to identity or lms2lmsp, lms2lmsd, lms2lmst
			mat4 control;
			switch (mType) {
			case protanopia:
			case protanomaly:
			simulation = lms2lmsp;
			if (mMode == Daltonizer::correction)
			correction = errp;
			break;
			case deuteranopia:
			case deuteranomaly:
			simulation = lms2lmsd;
			if (mMode == Daltonizer::correction)
			correction = errd;
			break;
			case tritanopia:
			case tritanomaly:
			simulation = lms2lmst;
			if (mMode == Daltonizer::correction)
			correction = errt;
			break;
			}

			if (true) {
			control = simulation;
			}

			mColorTransform = lms2rgb * control *
			(simulation * rgb2lms + correction * (rgb2lms - simulation * rgb2lms));
			}

			} /* namespace android */

services/surfaceflinger/Effects/Daltonizer.h

0 → 100644

+59 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* 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.
			*/

			#ifndef SF_EFFECTS_DALTONIZER_H_
			#define SF_EFFECTS_DALTONIZER_H_

			#include <ui/mat4.h>

			namespace android {

			class Daltonizer {
			public:
			enum ColorBlindnessTypes {
			protanopia, // L (red) cone missing
			deuteranopia, // M (green) cone missing
			tritanopia, // S (blue) cone missing
			protanomaly, // L (red) cone deficient
			deuteranomaly, // M (green) cone deficient (most common)
			tritanomaly // S (blue) cone deficient
			};

			enum Mode {
			simulation,
			correction
			};

			Daltonizer();
			~Daltonizer();

			void setType(ColorBlindnessTypes type);
			void setMode(Mode mode);

			// returns the color transform to apply in the shader
			const mat4& operator()();

			private:
			void update();

			ColorBlindnessTypes mType;
			Mode mMode;
			bool mDirty;
			mat4 mColorTransform;
			};

			} /* namespace android */
			#endif /* SF_EFFECTS_DALTONIZER_H_ */

services/surfaceflinger/Layer.cpp

+10 −14

Original line number	Original line	Diff line number	Diff line
	@@ -547,15 +547,11 @@ void Layer::drawWithOpenGL(

	// TODO: we probably want to generate the texture coords with the mesh		// TODO: we probably want to generate the texture coords with the mesh
	// here we assume that we only have 4 vertices		// here we assume that we only have 4 vertices
	Mesh::VertexArray texCoords(mMesh.getTexCoordArray());		Mesh::VertexArray<vec2> texCoords(mMesh.getTexCoordArray<vec2>());
	texCoords[0].s = left;		texCoords[0] = vec2(left, 1.0f - top);
	texCoords[0].t = 1.0f - top;		texCoords[1] = vec2(left, 1.0f - bottom);
	texCoords[1].s = left;		texCoords[2] = vec2(right, 1.0f - bottom);
	texCoords[1].t = 1.0f - bottom;		texCoords[3] = vec2(right, 1.0f - top);
	texCoords[2].s = right;
	texCoords[2].t = 1.0f - bottom;
	texCoords[3].s = right;
	texCoords[3].t = 1.0f - top;

	RenderEngine& engine(mFlinger->getRenderEngine());		RenderEngine& engine(mFlinger->getRenderEngine());
	engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(), s.alpha);		engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(), s.alpha);
	@@ -608,11 +604,11 @@ void Layer::computeGeometry(const sp<const DisplayDevice>& hw, Mesh& mesh) const
	// subtract the transparent region and snap to the bounds		// subtract the transparent region and snap to the bounds
	win = reduce(win, s.activeTransparentRegion);		win = reduce(win, s.activeTransparentRegion);

	Mesh::VertexArray position(mesh.getPositionArray());		Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
	tr.transform(position[0], win.left, win.top);		position[0] = tr.transform(win.left, win.top);
	tr.transform(position[1], win.left, win.bottom);		position[1] = tr.transform(win.left, win.bottom);
	tr.transform(position[2], win.right, win.bottom);		position[2] = tr.transform(win.right, win.bottom);
	tr.transform(position[3], win.right, win.top);		position[3] = tr.transform(win.right, win.top);
	for (size_t i=0 ; i<4 ; i++) {		for (size_t i=0 ; i<4 ; i++) {
	position[i].y = hw_h - position[i].y;		position[i].y = hw_h - position[i].y;
	}		}

services/surfaceflinger/RenderEngine/Description.cpp

+9 −1

Original line number	Original line	Diff line number	Diff line
	@@ -29,9 +29,10 @@ namespace android {
	Description::Description() :		Description::Description() :
	mUniformsDirty(true) {		mUniformsDirty(true) {
	mPlaneAlpha = 1.0f;		mPlaneAlpha = 1.0f;
	mPremultipliedAlpha = true;		mPremultipliedAlpha = false;
	mOpaque = true;		mOpaque = true;
	mTextureEnabled = false;		mTextureEnabled = false;
			mColorMatrixEnabled = false;

	memset(mColor, 0, sizeof(mColor));		memset(mColor, 0, sizeof(mColor));
	}		}
	@@ -81,4 +82,11 @@ void Description::setProjectionMatrix(const mat4& mtx) {
	mUniformsDirty = true;		mUniformsDirty = true;
	}		}

			void Description::setColorMatrix(const mat4& mtx) {
			const mat4 identity;
			mColorMatrix = mtx;
			mColorMatrixEnabled = (mtx != identity);
			}


	} /* namespace android */		} /* namespace android */