Android: zatrzymaj skalowanie obrazu w dół

Question

Próbuję narysować obrazek w widoku, ale mam problemy z zachowaniem skali oryginalnego obrazu. Zasadniczo mam mały widok i chciałbym pokazać część obrazu w widoku. Zamiarem jest zatem wykonanie tłumaczenia obrazu, aby w widoku pojawiła się inna część.

Bez względu na to, co próbuję, obraz jest automatycznie przeskalowany, aby dopasować go do widoku lub można wyświetlić cały obraz. Próbowałem grać z ustawieniami BitmapDrawable, ImageView i Layout bezskutecznie.

Ktoś wie, w jaki sposób można to osiągnąć?

Answer 1

Prawdopodobnie nie będzie to najbardziej efektywny sposób, ale jeśli nie zamierzasz go zbytnio ruszać, to zrobi. Traktuj to jak arkusz kalkulacyjny, użyj Bitmap.createBitmap (źródło bitmap, int x, int y, int width, int height), aby uzyskać żądaną sekcję z oryginalnej bitmapy jako własną mapę bitową, a następnie przekaż ją w zamian. Następnie przekaż ją zamiast całej bitmapy i będzie działać tylko z częścią, którą chcesz pokazać.

Answer 2

Wygląda na to, że chcesz mieć dużą kontrolkę ImageView w mniejszym widoku (działającym jak okno), a następnie przesunąć kontrolkę ImageView w jej obrębie, aby widoczna była tylko jej część.

Nie jestem do końca pewien, jak byś to zrobił, ale na pewno jest to możliwe z AbsoluteLayout i odrobiną majsterkowania.

Answer 3

Nadzieja Ten fragment kodu pomaga. Mam googleed to miesiąc temu. Jest to funkcja przewijania w przypadku większych zdjęć. Cały rozmiar wyświetlania jest ustawiony jako wysokość i szerokość widoku. Możesz to zmienić. a także może utrzymać kontrolę zoomu.

public class LargeImageScroller extends Activity { 

// Physical display width and height. 
private static int displayWidth = 0; 
private static int displayHeight = 0; 

/** Called when the activity is first created. */ 
@Override 
public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 

    // displayWidth and displayHeight will change depending on screen 
    // orientation. To get these dynamically, we should hook onSizeChanged(). 
    // This simple example uses only landscape mode, so it's ok to get them 
    // once on startup and use those values throughout. 
    Display display = ((WindowManager) 
      getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay(); 
    displayWidth = display.getWidth(); 
    displayHeight = display.getHeight(); 

    // SampleView constructor must be constructed last as it needs the 
    // displayWidth and displayHeight we just got. 
    setContentView(new SampleView(this)); 
} 

private static class SampleView extends View { 
    private static Bitmap bmLargeImage; //bitmap large enough to be scrolled 
    private static Rect displayRect = null; //rect we display to 
    private Rect scrollRect = null; //rect we scroll over our bitmap with 
    private int scrollRectX = 0; //current left location of scroll rect 
    private int scrollRectY = 0; //current top location of scroll rect 
    private float scrollByX = 0; //x amount to scroll by 
    private float scrollByY = 0; //y amount to scroll by 
    private float startX = 0; //track x from one ACTION_MOVE to the next 
    private float startY = 0; //track y from one ACTION_MOVE to the next 

    public SampleView(Context context) { 
      super(context); 

      // Destination rect for our main canvas draw. It never changes. 
      displayRect = new Rect(0, 0, displayWidth, displayHeight); 
      // Scroll rect: this will be used to 'scroll around' over the 
      // bitmap in memory. Initialize as above. 
      scrollRect = new Rect(0, 0, displayWidth, displayHeight); 

      // Load a large bitmap into an offscreen area of memory. 
      bmLargeImage = BitmapFactory.decodeResource(getResources(), 
       R.drawable.testlargeimage); 
    } 

    @Override 
    public boolean onTouchEvent(MotionEvent event) { 

      switch (event.getAction()) { 
       case MotionEvent.ACTION_DOWN: 
        // Remember our initial down event location. 
        startX = event.getRawX(); 
        startY = event.getRawY(); 
        break; 

       case MotionEvent.ACTION_MOVE: 
        float x = event.getRawX(); 
        float y = event.getRawY(); 
        // Calculate move update. This will happen many times 
        // during the course of a single movement gesture. 
        scrollByX = x - startX; //move update x increment 
        scrollByY = y - startY; //move update y increment 
        startX = x; //reset initial values to latest 
        startY = y; 
        invalidate(); //force a redraw 
        break; 
      } 
      return true; //done with this event so consume it 
    } 

    @Override 
    protected void onDraw(Canvas canvas) { 

      // Our move updates are calculated in ACTION_MOVE in the opposite direction 
      // from how we want to move the scroll rect. Think of this as dragging to 
      // the left being the same as sliding the scroll rect to the right. 
      int newScrollRectX = scrollRectX - (int)scrollByX; 
      int newScrollRectY = scrollRectY - (int)scrollByY; 

      // Don't scroll off the left or right edges of the bitmap. 
      if (newScrollRectX < 0) 
       newScrollRectX = 0; 
      else if (newScrollRectX > (bmLargeImage.getWidth() - displayWidth)) 
       newScrollRectX = (bmLargeImage.getWidth() - displayWidth); 

      // Don't scroll off the top or bottom edges of the bitmap. 
      if (newScrollRectY < 0) 
       newScrollRectY = 0; 
      else if (newScrollRectY > (bmLargeImage.getHeight() - displayHeight)) 
       newScrollRectY = (bmLargeImage.getHeight() - displayHeight); 

      // We have our updated scroll rect coordinates, set them and draw. 
      scrollRect.set(newScrollRectX, newScrollRectY, 
       newScrollRectX + displayWidth, newScrollRectY + displayHeight); 
      Paint paint = new Paint(); 
      canvas.drawBitmap(bmLargeImage, scrollRect, displayRect, paint); 

      // Reset current scroll coordinates to reflect the latest updates, 
      // so we can repeat this update process. 
      scrollRectX = newScrollRectX; 
      scrollRectY = newScrollRectY; 

    } 
} 
}