src/com/android/gallery3d/filtershow/filters/BaseFiltersManager.java

   1 /*
   2  * Copyright (C) 2013 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.android.gallery3d.filtershow.filters;
  17
  18 import android.content.Context;
  19 import android.content.res.Resources;
  20 import android.util.Log;
  21
  22 import com.android.gallery3d.R;
  23 import com.android.gallery3d.filtershow.imageshow.GeometryMetadata;
  24 import com.android.gallery3d.filtershow.pipeline.ImagePreset;
  25
  26 import java.util.ArrayList;
  27 import java.util.HashMap;
  28 import java.util.Vector;
  29
  30 public abstract class BaseFiltersManager implements FiltersManagerInterface {
  31     protected HashMap<Class, ImageFilter> mFilters = null;
  32     protected HashMap<String, FilterRepresentation> mRepresentationLookup = null;
  33     private static final String LOGTAG = "BaseFiltersManager";
  34
  35     protected ArrayList<FilterRepresentation> mLooks = new ArrayList<FilterRepresentation>();
  36     protected ArrayList<FilterRepresentation> mBorders = new ArrayList<FilterRepresentation>();
  37     protected ArrayList<FilterRepresentation> mTools = new ArrayList<FilterRepresentation>();
  38     protected ArrayList<FilterRepresentation> mEffects = new ArrayList<FilterRepresentation>();
  39
  40     protected void init() {
  41         mFilters = new HashMap<Class, ImageFilter>();
  42         mRepresentationLookup = new HashMap<String, FilterRepresentation>();
  43         Vector<Class> filters = new Vector<Class>();
  44         addFilterClasses(filters);
  45         for (Class filterClass : filters) {
  46             try {
  47                 Object filterInstance = filterClass.newInstance();
  48                 if (filterInstance instanceof ImageFilter) {
  49                     mFilters.put(filterClass, (ImageFilter) filterInstance);
  50
  51                     FilterRepresentation rep =
  52                         ((ImageFilter) filterInstance).getDefaultRepresentation();
  53                     if (rep != null) {
  54                         addRepresentation(rep);
  55                     }
  56                 }
  57             } catch (InstantiationException e) {
  58                 e.printStackTrace();
  59             } catch (IllegalAccessException e) {
  60                 e.printStackTrace();
  61             }
  62         }
  63     }
  64
  65     public void addRepresentation(FilterRepresentation rep) {
  66         mRepresentationLookup.put(rep.getSerializationName(), rep);
  67     }
  68
  69     public FilterRepresentation createFilterFromName(String name) {
  70         try {
  71             return mRepresentationLookup.get(name).clone();
  72         } catch (Exception e) {
  73             Log.v(LOGTAG, "unable to generate a filter representation for \"" + name + "\"");
  74             e.printStackTrace();
  75         }
  76         return null;
  77     }
  78
  79     public ImageFilter getFilter(Class c) {
  80         return mFilters.get(c);
  81     }
  82
  83     @Override
  84     public ImageFilter getFilterForRepresentation(FilterRepresentation representation) {
  85         return mFilters.get(representation.getFilterClass());
  86     }
  87
  88     public FilterRepresentation getRepresentation(Class c) {
  89         ImageFilter filter = mFilters.get(c);
  90         if (filter != null) {
  91             return filter.getDefaultRepresentation();
  92         }
  93         return null;
  94     }
  95
  96     public void freeFilterResources(ImagePreset preset) {
  97         if (preset == null) {
  98             return;
  99         }
 100         Vector<ImageFilter> usedFilters = preset.getUsedFilters(this);
 101         for (Class c : mFilters.keySet()) {
 102             ImageFilter filter = mFilters.get(c);
 103             if (!usedFilters.contains(filter)) {
 104                 filter.freeResources();
 105             }
 106         }
 107     }
 108
 109     public void freeRSFilterScripts() {
 110         for (Class c : mFilters.keySet()) {
 111             ImageFilter filter = mFilters.get(c);
 112             if (filter != null && filter instanceof ImageFilterRS) {
 113                 ((ImageFilterRS) filter).resetScripts();
 114             }
 115         }
 116     }
 117
 118     protected void addFilterClasses(Vector<Class> filters) {
 119         filters.add(ImageFilterTinyPlanet.class);
 120         filters.add(ImageFilterRedEye.class);
 121         filters.add(ImageFilterWBalance.class);
 122         filters.add(ImageFilterExposure.class);
 123         filters.add(ImageFilterVignette.class);
 124         filters.add(ImageFilterContrast.class);
 125         filters.add(ImageFilterShadows.class);
 126         filters.add(ImageFilterHighlights.class);
 127         filters.add(ImageFilterVibrance.class);
 128         filters.add(ImageFilterSharpen.class);
 129         filters.add(ImageFilterCurves.class);
 130         filters.add(ImageFilterDraw.class);
 131         filters.add(ImageFilterHue.class);
 132         filters.add(ImageFilterSaturated.class);
 133         filters.add(ImageFilterBwFilter.class);
 134         filters.add(ImageFilterNegative.class);
 135         filters.add(ImageFilterEdge.class);
 136         filters.add(ImageFilterKMeans.class);
 137         filters.add(ImageFilterFx.class);
 138         filters.add(ImageFilterBorder.class);
 139         filters.add(ImageFilterParametricBorder.class);
 140         filters.add(ImageFilterGeometry.class);
 141     }
 142
 143     public ArrayList<FilterRepresentation> getLooks() {
 144         return mLooks;
 145     }
 146
 147     public ArrayList<FilterRepresentation> getBorders() {
 148         return mBorders;
 149     }
 150
 151     public ArrayList<FilterRepresentation> getTools() {
 152         return mTools;
 153     }
 154
 155     public ArrayList<FilterRepresentation> getEffects() {
 156         return mEffects;
 157     }
 158
 159     public void addBorders(Context context) {
 160
 161     }
 162
 163     public void addLooks(Context context) {
 164         int[] drawid = {
 165                 R.drawable.filtershow_fx_0005_punch,
 166                 R.drawable.filtershow_fx_0000_vintage,
 167                 R.drawable.filtershow_fx_0004_bw_contrast,
 168                 R.drawable.filtershow_fx_0002_bleach,
 169                 R.drawable.filtershow_fx_0001_instant,
 170                 R.drawable.filtershow_fx_0007_washout,
 171                 R.drawable.filtershow_fx_0003_blue_crush,
 172                 R.drawable.filtershow_fx_0008_washout_color,
 173                 R.drawable.filtershow_fx_0006_x_process
 174         };
 175
 176         int[] fxNameid = {
 177                 R.string.ffx_punch,
 178                 R.string.ffx_vintage,
 179                 R.string.ffx_bw_contrast,
 180                 R.string.ffx_bleach,
 181                 R.string.ffx_instant,
 182                 R.string.ffx_washout,
 183                 R.string.ffx_blue_crush,
 184                 R.string.ffx_washout_color,
 185                 R.string.ffx_x_process
 186         };
 187
 188         // Do not localize.
 189         String[] serializationNames = {
 190                 "LUT3D_PUNCH",
 191                 "LUT3D_VINTAGE",
 192                 "LUT3D_BW",
 193                 "LUT3D_BLEACH",
 194                 "LUT3D_INSTANT",
 195                 "LUT3D_WASHOUT",
 196                 "LUT3D_BLUECRUSH",
 197                 "LUT3D_WASHOUT",
 198                 "LUT3D_XPROCESS"
 199         };
 200
 201         FilterFxRepresentation nullFx =
 202                 new FilterFxRepresentation(context.getString(R.string.none),
 203                         0, R.string.none);
 204         mLooks.add(nullFx);
 205
 206         for (int i = 0; i < drawid.length; i++) {
 207             FilterFxRepresentation fx = new FilterFxRepresentation(
 208                     context.getString(fxNameid[i]), drawid[i], fxNameid[i]);
 209             fx.setSerializationName(serializationNames[i]);
 210             mLooks.add(fx);
 211             addRepresentation(fx);
 212         }
 213     }
 214
 215     public void addEffects() {
 216         mEffects.add(getRepresentation(ImageFilterTinyPlanet.class));
 217         mEffects.add(getRepresentation(ImageFilterWBalance.class));
 218         mEffects.add(getRepresentation(ImageFilterExposure.class));
 219         mEffects.add(getRepresentation(ImageFilterVignette.class));
 220         mEffects.add(getRepresentation(ImageFilterContrast.class));
 221         mEffects.add(getRepresentation(ImageFilterShadows.class));
 222         mEffects.add(getRepresentation(ImageFilterHighlights.class));
 223         mEffects.add(getRepresentation(ImageFilterVibrance.class));
 224         mEffects.add(getRepresentation(ImageFilterSharpen.class));
 225         mEffects.add(getRepresentation(ImageFilterCurves.class));
 226         mEffects.add(getRepresentation(ImageFilterHue.class));
 227         mEffects.add(getRepresentation(ImageFilterSaturated.class));
 228         mEffects.add(getRepresentation(ImageFilterBwFilter.class));
 229         mEffects.add(getRepresentation(ImageFilterNegative.class));
 230         mEffects.add(getRepresentation(ImageFilterEdge.class));
 231         mEffects.add(getRepresentation(ImageFilterKMeans.class));
 232     }
 233
 234     public void addTools(Context context) {
 235         GeometryMetadata geo = new GeometryMetadata();
 236         int[] editorsId = geo.getEditorIds();
 237
 238         int[] textId = {
 239                 R.string.crop,
 240                 R.string.straighten,
 241                 R.string.rotate,
 242                 R.string.mirror
 243         };
 244
 245         int[] overlayId = {
 246                 R.drawable.filtershow_button_geometry_crop,
 247                 R.drawable.filtershow_button_geometry_straighten,
 248                 R.drawable.filtershow_button_geometry_rotate,
 249                 R.drawable.filtershow_button_geometry_flip
 250         };
 251
 252         for (int i = 0; i < editorsId.length; i++) {
 253             int editorId = editorsId[i];
 254             GeometryMetadata geometry = new GeometryMetadata(geo);
 255             geometry.setEditorId(editorId);
 256             geometry.setTextId(textId[i]);
 257             geometry.setOverlayId(overlayId[i]);
 258             geometry.setOverlayOnly(true);
 259             if (geometry.getTextId() != 0) {
 260                 geometry.setName(context.getString(geometry.getTextId()));
 261             }
 262             mTools.add(geometry);
 263         }
 264
 265         mTools.add(getRepresentation(ImageFilterRedEye.class));
 266         mTools.add(getRepresentation(ImageFilterDraw.class));
 267     }
 268
 269     public void setFilterResources(Resources resources) {
 270         ImageFilterBorder filterBorder = (ImageFilterBorder) getFilter(ImageFilterBorder.class);
 271         filterBorder.setResources(resources);
 272         ImageFilterFx filterFx = (ImageFilterFx) getFilter(ImageFilterFx.class);
 273         filterFx.setResources(resources);
 274     }
 275 }