Java tutorial
/* * Copyright (C) 2014 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. */ package android.hardware.camera2.params; import static com.android.internal.util.Preconditions.*; /** * Immutable class to store a 4-element vector of floats indexable by a bayer RAW 2x2 pixel block. */ public final class RggbChannelVector { /** * The number of color channels in this vector. */ public static final int COUNT = 4; /** Red color channel in a bayer Raw pattern. */ public static final int RED = 0; /** Green color channel in a bayer Raw pattern used by the even rows. */ public static final int GREEN_EVEN = 1; /** Green color channel in a bayer Raw pattern used by the odd rows. */ public static final int GREEN_ODD = 2; /** Blue color channel in a bayer Raw pattern. */ public static final int BLUE = 3; /** * Create a new {@link RggbChannelVector} from an RGGB 2x2 pixel. * * <p>All pixel values are considered normalized within {@code [0.0f, 1.0f]} * (i.e. {@code 1.0f} could be linearized to {@code 255} if converting to a * non-floating point pixel representation).</p> * * <p>All arguments must be finite; NaN and infinity is not allowed.</p> * * @param red red pixel * @param greenEven green pixel (even row) * @param greenOdd green pixel (odd row) * @param blue blue pixel * * @throws IllegalArgumentException if any of the arguments were not finite */ public RggbChannelVector(final float red, final float greenEven, final float greenOdd, final float blue) { mRed = checkArgumentFinite(red, "red"); mGreenEven = checkArgumentFinite(greenEven, "greenEven"); mGreenOdd = checkArgumentFinite(greenOdd, "greenOdd"); mBlue = checkArgumentFinite(blue, "blue"); } /** * Get the red component. * * @return a floating point value (guaranteed to be finite) */ public final float getRed() { return mRed; } /** * Get the green (even rows) component. * * @return a floating point value (guaranteed to be finite) */ public float getGreenEven() { return mGreenEven; } /** * Get the green (odd rows) component. * * @return a floating point value (guaranteed to be finite) */ public float getGreenOdd() { return mGreenOdd; } /** * Get the blue component. * * @return a floating point value (guaranteed to be finite) */ public float getBlue() { return mBlue; } /** * Get the component by the color channel index. * * <p>{@code colorChannel} must be one of {@link #RED}, {@link #GREEN_EVEN}, {@link #GREEN_ODD}, * {@link #BLUE}.</p> * * @param colorChannel greater or equal to {@code 0} and less than {@link #COUNT} * @return a floating point value (guaranteed to be finite) * * @throws IllegalArgumentException if {@code colorChannel} was out of range */ public float getComponent(final int colorChannel) { if (colorChannel < 0 || colorChannel >= COUNT) { throw new IllegalArgumentException("Color channel out of range"); } switch (colorChannel) { case RED: return mRed; case GREEN_EVEN: return mGreenEven; case GREEN_ODD: return mGreenOdd; case BLUE: return mBlue; default: throw new AssertionError("Unhandled case " + colorChannel); } } /** * Copy the vector into the destination in the order {@code [R, Geven, Godd, B]}. * * @param destination * an array big enough to hold at least {@value #COUNT} elements after the * {@code offset} * @param offset * a non-negative offset into the array * * @throws NullPointerException * If {@code destination} was {@code null} * @throws ArrayIndexOutOfBoundsException * If there's not enough room to write the elements at the specified destination and * offset. */ public void copyTo(final float[] destination, final int offset) { checkNotNull(destination, "destination must not be null"); if (destination.length - offset < COUNT) { throw new ArrayIndexOutOfBoundsException("destination too small to fit elements"); } destination[offset + RED] = mRed; destination[offset + GREEN_EVEN] = mGreenEven; destination[offset + GREEN_ODD] = mGreenOdd; destination[offset + BLUE] = mBlue; } /** * Check if this {@link RggbChannelVector} is equal to another {@link RggbChannelVector}. * * <p>Two vectors are only equal if and only if each of the respective elements is equal.</p> * * @return {@code true} if the objects were equal, {@code false} otherwise */ @Override public boolean equals(final Object obj) { if (obj == null) { return false; } else if (this == obj) { return true; } else if (obj instanceof RggbChannelVector) { final RggbChannelVector other = (RggbChannelVector) obj; return mRed == other.mRed && mGreenEven == other.mGreenEven && mGreenOdd == other.mGreenOdd && mBlue == other.mBlue; } return false; } /** * {@inheritDoc} */ @Override public int hashCode() { return Float.floatToIntBits(mRed) ^ Float.floatToIntBits(mGreenEven) ^ Float.floatToIntBits(mGreenOdd) ^ Float.floatToIntBits(mBlue); } /** * Return the RggbChannelVector as a string representation. * * <p> {@code "RggbChannelVector{R:%f, G_even:%f, G_odd:%f, B:%f}"}, where each * {@code %f} respectively represents one of the the four color channels. </p> * * @return string representation of {@link RggbChannelVector} */ @Override public String toString() { return String.format("RggbChannelVector%s", toShortString()); } /** * Return the RggbChannelVector as a string in compact form. * * <p> {@code "{R:%f, G_even:%f, G_odd:%f, B:%f}"}, where each {@code %f} * respectively represents one of the the four color channels. </p> * * @return compact string representation of {@link RggbChannelVector} */ private String toShortString() { return String.format("{R:%f, G_even:%f, G_odd:%f, B:%f}", mRed, mGreenEven, mGreenOdd, mBlue); } private final float mRed; private final float mGreenEven; private final float mGreenOdd; private final float mBlue; }