Hy Tobi
,
der IO FileManager muss auf dem Device installiert sein, dann kann man ihn folgendermaßen nutzen:
Intent fileIntent = new Intent("org.openintents.action.PICK_FILE");
protected void onActivityResult(int requestCode, int resultCode, Intent fileIntent) {
// TODO Auto-generated method stub
super.onActivityResult(requestCode, resultCode, fileIntent);
path = fileIntent.getData().toString();
}
Ich verzweifele mittlerweile aber an meinem Code...
Deinen Tipp mit der Methode habe ich umgesetzt (vor lauter Bäumen den Wald nicht mehr gesehen).
Allerdings bekomme ich nun an dieser Stelle eine Nullpointerexception:
image = BitmapFactory.decodeFile(this.path);
pixel = new int[image.getWidth()*image.getHeight()];
wenn ich das Bild so lade, funktioniert es image = BitmapFactory.decodeResource(getResources(),R.drawable.image);.
Anbei mein Code, vllt. hast du ja noch eine Idee:
Die Hauptactivity:1public class StartView extends Activity implements OnClickListener{
2 /**Die Buttons*/
3 private Button file, start;
4 /**Ein Intent zum Starten einer zweiten Activity*/
5 private Intent mainIntent;
6 private Intent fileIntent;
7
8 private String path;
9
10 public static String DATEI_PFAD="pfad";
11
12 @Override
13 protected void onCreate(Bundle savedInstanceState) {
14 // TODO Auto-generated method stub
15 super.onCreate(savedInstanceState);
16 setContentView(R.layout.main);
17
18 file = (Button)findViewById(R.id.choose);
19 file.setOnClickListener(this);
20
21 start = (Button)findViewById(R.id.start);
22 start.setOnClickListener(this);
23
24 mainIntent = new Intent(this, MainView.class);
25 fileIntent = new Intent("org.openintents.action.PICK_FILE");
26 }
27
28 /**
29 * Listener Methode für die beiden Buttons
30 */
31 public void onClick(View v) {
32 // TODO Auto-generated method stub
33 if(v == file || v== start){
34 if(v == file){
35 startActivityForResult(fileIntent, 1);
36 return;
37 }
38 else{
39 //Gib der Activity den Pfad zur gewählten Datei mit
40 mainIntent.putExtra(DATEI_PFAD, this.path);
41 this.startActivity(mainIntent);
42
43 }
44 }
45 }
46
47 @Override
48 protected void onActivityResult(int requestCode, int resultCode, Intent fileIntent) {
49 // TODO Auto-generated method stub
50 super.onActivityResult(requestCode, resultCode, fileIntent);
51 path = fileIntent.getData().toString();
52 }
53
54}
Die Activity mit dem eigentlichen App1package de.view;
2
3
4import android.app.Activity;
5import android.content.Intent;
6import android.os.Bundle;
7import android.view.Menu;
8import android.view.MenuInflater;
9import android.view.MenuItem;
10
11/**
12 * Die Hauptklasse des Projektes ImageDisplay
13 * @author Tobias Heine
14 *
15 */
16public class MainView extends Activity {
17 /** Called when the activity is first created. */
18
19 /**Eine Referenz auf die Klasse DrawView wird erstellt*/
20 private DrawView view;
21
22 /**Ein Intent zum Starten einer Activity*/
23 private Intent startIntent;
24 /**Pfad zu der Datei, welche in der Activity StartView ausgewählt wurde*/
25 private String path;
26 /**
27 *Die Activity wird gestartet und dem Inhalt wird eine DrawView zugewiesen
28 */
29 public void onCreate(Bundle savedInstanceState) {
30 super.onCreate(savedInstanceState);
31 view = new DrawView(this);
32 setContentView(view);
33 //Ein Intent, der auf die Menü-Activity zeigt
34 startIntent = new Intent(this, StartView.class);
35 //Der Pfad zur ausgewählten Datei
36 Bundle meinBundle = getIntent().getExtras();
37 path = (String)meinBundle.getString(StartView.DATEI_PFAD);
38 //Der View den Pfad mitteilen
39 view.setPath(path);
40 }
41
42 /**
43 * Das Options Menü wird erstellt und die einzelnen Menüpunkte hinzugefügt
44 */
45 public boolean onCreateOptionsMenu(Menu menu) {
46 //MenuInflater, der anhand von menu.xml das Menü baut
47 MenuInflater inflater = getMenuInflater();
48 inflater.inflate(R.menu.menu, menu);
49 return true;
50 }
51
52 /**
53 * Listener Methode für die einzelnen Menüpunkte
54 */
55 public boolean onOptionsItemSelected(MenuItem item) {
56
57 switch (item.getItemId()) {
58 case R.id.ORIGINAL:
59 view.drawOriginal();
60 return true;
61
62 case R.id.GREY_ID:
63 view.drawGrey();
64 return true;
65
66 case R.id.NEGATIVE_ID:
67 view.drawNegative();
68 return true;
69
70 case R.id.SEPIA:
71 view.drawSepia();
72 return true;
73
74 case R.id.BEST_COLORS:
75 view.drawBestColors();
76 return true;
77
78 case R.id.ERROR_DIFF:
79 view.drawErrorDiff();
80 return true;
81
82 case R.id.BLACK_WHITE:
83 view.drawBlackWhite();
84 return true;
85
86 case R.id.MENU:
87 this.startActivity(startIntent);
88 return true;
89
90 default:
91 return false;
92 }
93 }
94
95 public String getPath(){
96 return path;
97 }
98}
Und noch die View:[code]package de.view;
import de.view.R;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.view.View;
public class DrawView extends View
{
MainView main = new MainView();
/**Pfad zu der Bitmap-Datei*/
String path;
/**Das Canvas auf dem die Bilder gezeichnet werden*/
Canvas bitmapCanvas;
/**Die Bilddatei, welche auf das Canvas gezeichnet wird*/
Bitmap image;
/**Variable zum Zwischenspeichern der Farbe der Pixel*/
int aktcolor;
/**Die sechs bestmöglichen Farben*/
int farben [][] = {
{46,100,138},
{104,134,162},
{102,90,81},
{34,37,36},
{209,207,208},
{158,144,134}
};
/**Die einzelnen Distanzen*/
int [] distanz = new int [farben.length];
/**Boolean-Wert, damit init() nur einmalig ausgeführt wird*/
boolean isInitialized;
/**Notwendiges Paint Objekt*/
Paint paint = new Paint();
/**Array zum Speichern der Pixel*/
int[] pixel;
/**Wert zum Ermitteln der Fehlerdifussion*/
int diff_error;
/**
* Konstruktor
* @param context
*/
public DrawView(Context context)
{
super(context);
isInitialized = false;
}
/**
* Canvas wird initialisiert es wird ein Bitmap zugewiesen
*/
private void init()
{
// image = BitmapFactory.decodeResource(getResources(),R.drawable.image);
// Das Image wird anhand dem übergebenen Pfad erstellt
image = BitmapFactory.decodeFile(this.path);
pixel = new int[image.getWidth()*image.getHeight()];
//Alle Pixel werden in dem Array pixel gespeichert
image.getPixels(pixel, 0, image.getWidth(), 0, 0, image.getWidth(), image.getHeight());
bitmapCanvas = new Canvas();
bitmapCanvas.setBitmap(image);
isInitialized = true;
}
/**
* Methode zum Zeichnen des Bildes
* @param canvas Das Canvas, auf dem gezeichnet wird
*/
public void onDraw(Canvas canvas)
{
if (!isInitialized){
init();
}
canvas.drawBitmap(image, 0, 0, paint);
}
/**
* Negativbild
*/
public void drawNegative(){
for(int y=0;y<image.getHeight();y++){
for(int x=0;x<image.getWidth();x++){
aktcolor = image.getPixel(x, y);
int r = (aktcolor >> 16) & 0xff;
int g = (aktcolor >> 8) & 0xff;
int b = aktcolor & 0xff;
//Negativ-Wert berechnen
int rn = 255-r;
int gn = 255-g;
int bn = 255-b;
// Hier muessen die neuen RGB-Werte wieder auf den Bereich von 0 bis 255 begrenzt werden
if(rn>255){
rn = 255;
}
if(gn>255){
gn = 255;
}
if(bn>255){
bn = 255;
}
if(rn<0){
rn = 0;
}
if(gn<0){
gn = 0;
}
if(bn<0){
bn = 0;
}
image.setPixel(x, y, Color.rgb(rn, gn, bn));
}
}
invalidate();
}
/**
* Sepia-Färbung
*/
public void drawSepia(){
for(int y=0;y<image.getHeight();y++){
for(int x=0;x<image.getWidth();x++){
aktcolor = image.getPixel(x, y);
int r = (aktcolor >> 16) & 0xff;
int g = (aktcolor >> 8) & 0xff;
int b = aktcolor & 0xff;
//Grauwert berechnen
int grau = (int) (r * 0.3 + g * 0.59 + b * 0.11);
int rn = grau+95;
int gn = grau+65;
int bn = grau;
// Hier muessen die neuen RGB-Werte wieder auf den Bereich von 0 bis 255 begrenzt werden
if(rn>255){
rn = 255;
}
if(gn>255){
gn = 255;
}
if(bn>255){
bn = 255;
}
if(rn<0){
rn = 0;
}
if(gn<0){
gn = 0;
}
if(bn<0){
bn = 0;
}
image.setPixel(x, y, Color.rgb(rn, gn, bn));
}
}
invalidate();
}
/**
* Graustufenbild
*/
public void drawGrey(){
for(int y=0;y<image.getHeight();y++){
for(int x=0;x<image.getWidth();x++){
aktcolor = image.getPixel(x, y);
int r = (aktcolor >> 16) & 0xff;
int g = (aktcolor >> 8) & 0xff;
int b = aktcolor & 0xff;
int grau = (int) (r * 0.3 + g * 0.59 + b * 0.11);
int rn = grau;
int gn = grau;
int bn = grau;
// Hier muessen die neuen RGB-Werte wieder auf den Bereich von 0 bis 255 begrenzt werden
if(rn>255){
rn = 255;
}
if(gn>255){
gn = 255;
}
if(bn>255){
bn = 255;
}
if(rn<0){
rn = 0;
}
if(gn<0){
gn = 0;
}
if(bn<0){
bn = 0;
}
image.setPixel(x, y, Color.rgb(rn, gn, bn));
}
}
invalidate();
}
/**
* Originalbild
*/
public void drawOriginal(){
//Die Originalpixel aus dem Array pixel werden wieder in das Bild geschrieben
image.setPixels(pixel, 0, image.getWidth(), 0, 0, image.getWidth(), image.getHeight());
invalidate();
}
/**
* Auswahl aus den vorgegebenen besten Farben
*/
public void drawBestColors() {
for(int y=0;y<image.getHeight();y++){
for(int x=0;x<image.getWidth();x++){
aktcolor = image.getPixel(x, y);
int r = (aktcolor >> 16) & 0xff;
int g = (aktcolor >> 8) & 0xff;
int b = aktcolor & 0xff;
//Die aktuellen Farben werden in einem Array gespeichert
int [] aktfarben = {r,g,b};
//Eine minimale Distanz mit einem großen Wert wird erstellt
int minDistanz=255;
//Die Variable für die jeweilige Sollfarbe des einzelnen Pixels
int sollfarbe=-1;
//Distanzen zwischen dem aktuellen Farbvektor und den 6 möglichen Farben berechnen
for(int i=0;i<farben.length;i++){
distanz[i]=(int) Math.sqrt( (aktfarben[0]-farben[i][0])*(aktfarben[0]-farben[i][0]) + (aktfarben[1]-farben[i][1])*(aktfarben[1]-farben[i][1]) + (aktfarben[2]-farben[i][2])*(aktfarben[2]-farben[i][2]));
}
//
int rn=aktfarben[0];
int gn=aktfarben[1];
int bn=aktfarben[2];
//die kleinste Distanz bestimmen und anhand dieser die Sollfarbe für den aktuellen Pixel bestimmen
for(int i=0;i<distanz.length;i++){
if( minDistanz>distanz[i]){
minDistanz=distanz[i];
sollfarbe=i;
}
}
rn=farben[sollfarbe][0];
gn=farben[sollfarbe][1];
bn=farben[sollfarbe][2];
image.setPixel(x, y, Color.rgb(rn, gn, bn));
}
}
invalidate();
}
/**
* Fehlerdifussion
*/
public void drawErrorDiff(){
for(int y=0;y<image.getHeight();y++){
for(int x=0;x<image.getWidth();x++){
aktcolor = image.getPixel(x, y);
int r = (aktcolor >> 16) & 0xff;
int g = (aktcolor >> 8) & 0xff;
int b = aktcolor & 0xff;
//Grauwert berechnen und Fehler abziehen
int grau = (int) (r * 0.3 + g * 0.59 + b * 0.11)-diff_error;
//Schwarz-Weiss Werte berechnen
int sw= (grau>=128) ? 255 : 0;
//Fehlerdifferenz für den nächsten Pixel berechnen
diff_error = sw-grau;
int rn = sw;
int gn = sw;
int bn = sw;
// Hier muessen die neuen RGB-Werte wieder auf den Bereich von 0 bis 255 begrenzt werden
if(rn>255){
rn = 255;
}
if(gn>255){
gn = 255;
}
if(bn>255){
bn = 255;
}
if(rn<0){
rn = 0;
}
if(gn<0){
gn = 0;
}
if(bn<0){
bn = 0;
}
image.setPixel(x, y, Color.rgb(rn, gn, bn));
}
}
invalidate();
}
/**
* Schwarz/Weiß
*/
public void drawBlackWhite(){
for(int y=0;y<image.getHeight();y++){
for(int x=0;x<image.getWidth();x++){
aktcolor = image.getPixel(x, y);
int r = (aktcolor >> 16) & 0xff;
int g = (aktcolor >> 8) & 0xff;
int b = aktcolor & 0xff;
//Grauwert berechnen
int grau = (int) (r * 0.3 + g * 0.59 + b * 0.11);
int rn = grau;
int gn = grau;
int bn = grau;
//Schwarz-Weiss Werte berechnen
rn= (rn>=128) ? 255 : 0;
gn= (gn>=128) ? 255 : 0;
bn= (bn>=128) ? 255 : 0;
image.setPixel(x, y, Color.rgb(rn, gn, bn));
}
}
invalidate();
}
/**
*
*/
public void setPath(String path){
this.path=path;
}
}[/code]
— geändert am 26.05.2010, 07:45:03
.
Empfohlener redaktioneller Inhalt
Mit Deiner Zustimmung wird hier ein externer Inhalt geladen.
Mit Klick auf den oben stehenden Button erklärst Du Dich damit einverstanden, dass Dir externe Inhalte angezeigt werden dürfen. Dabei können personenbezogene Daten an Drittanbieter übermittelt werden. Mehr Infos dazu findest Du in unserer Datenschutzerklärung.