p图软件原理 美图秀秀的工作原理是什么

美图秀秀是通过一下程序代码来实现一键美图的：

import android.app.Activity;

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.graphics.Path;

import android.graphics.RectF;

import android.graphics.Region;

import android.graphics.drawable.BitmapDrawable;

import android.os.Bundle;

import android.util.DisplayMetrics;

import android.util.Log;

import android.view.MotionEvent;

import android.view.View;

import android.view.Window;

import android.view.WindowManager;

import android.widget.Toast;

public class ShowPathActivity extends Activity {

@Override

protected void onCreate(Bundle savedInstanceState) {

// TODO Auto-generated method stub

super.onCreate(savedInstanceState);

requestWindowFeature(Window.FEATURE_NO_TITLE);

getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,

WindowManager.LayoutParams.FLAG_FULLSCREEN);

setContentView(new PathView(this));

}

}

class PathView extends View {

private Context mCtx;

private Path[] mPath;

private Bitmap[] mBmp;

private boolean[] mBmpFlag;

private float[][] mPathLT;

private float[][] mPathOffset;

int mPathNum = 3;

private int border = 6;

private int viewWdh, viewHgt, itemHgt;

public static int PICIDS[] = { R.drawable.showguide1,

R.drawable.showguide2, R.drawable.showguide3,

R.drawable.showguide4, R.drawable.showguide5, R.drawable.showguide6 };

public PathView(Context context) {

super(context);

mCtx = context;

initialView();

initPath();

}

private void initPath() {

// mPathNum = (int) (Math.random() * 10);

mPath = new Path[mPathNum];

for (int i = 0; i < mPathNum; i++) {

mPath[i] = new Path();

}

mBmpFlag = new boolean[mPathNum];

mPathLT = new float[mPathNum][2];

mPathOffset = new float[mPathNum][2];

for (int i = 0; i < mPathNum; i++) {

mBmpFlag[i] = false;

mPathLT[i][0] = 0f;

mPathLT[i][1] = 0f;

mPathOffset[i][0] = 0f;

mPathOffset[i][1] = 0f;

}

for (int i = 0; i < mPathNum; i++) {

mPathLT[i][0] = 0;

mPathLT[i][1] = (itemHgt + border)*i;

mPath[i].moveTo(mPathLT[i][0], mPathLT[i][1]);

mPath[i].lineTo(viewWdh, mPathLT[i][1]);

mPath[i].lineTo(viewWdh, mPathLT[i][1] + itemHgt);

mPath[i].lineTo(0, mPathLT[i][1] + itemHgt);

mPath[i].close();

}

// get bitmap

mBmp = new Bitmap[mPathNum];

for (int i = 0; i < mPathNum; i++) {

BitmapFactory.Options opt = new BitmapFactory.Options();

opt.inJustDecodeBounds = true;

BitmapFactory.decodeResource(getResources(), PICIDS[i], opt);

int bmpWdh = opt.outWidth;

int bmpHgt = opt.outHeight;

int size = caculateSampleSize(bmpWdh, bmpHgt, viewWdh, itemHgt);

opt.inJustDecodeBounds = false;

opt.inSampleSize = size;

mBmp[i] = BitmapFactory.decodeResource(getResources(), PICIDS[i],

opt);

}

}

private int caculateSampleSize(int picWdh, int picHgt, int showWdh,

int showHgt) {

// 如果此时显示区域比图片大，直接返回

if ((showWdh < picWdh) || (showHgt < picHgt)) {

int wdhSample = picWdh / showWdh;

int hgtSample = picHgt / showHgt;

// 利用小的来处理

int sample = wdhSample > hgtSample ? hgtSample : wdhSample;

int minSample = 2;

while (sample > minSample) {

minSample *= 2;

}

return minSample >> 1;

} else {

return 1;

}

}

private void initialView() {

DisplayMetrics display = mCtx.getResources().getDisplayMetrics();

viewWdh = display.widthPixels;

itemHgt = display.heightPixels >> 2;

viewHgt = itemHgt * 3 + 2 * border;

Log.d("screen parameter", "wdh = " + viewWdh + ":hgt = "

+ display.heightPixels);

}

@Override

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

// TODO Auto-generated method stub

super.onMeasure(widthMeasureSpec, heightMeasureSpec);

setMeasuredDimension(viewWdh, viewHgt);

}

@Override

protected void onDraw(Canvas canvas) {

super.onDraw(canvas);

canvas.drawColor(Color.GRAY);// 显示背景颜色

Paint paint = new Paint();

paint.setColor(Color.GRAY);

canvas.drawPaint(paint);

// draw1(canvas);

draw2(canvas, paint);

}

private void draw1(Canvas canvas){

for (int i = 0; i < mPathNum; i++) {

canvas.save();

canvas.clipPath(mPath[i]);

BitmapDrawable mDrawable = new BitmapDrawable(mBmp[i]);

mDrawable.setBounds(0, (itemHgt + border) * i, viewWdh, (itemHgt + border) * i + itemHgt);

mDrawable.draw(canvas);

canvas.restore();

}

}

private void draw2(Canvas canvas, Paint paint){

for (int i = 0; i < mPathNum; i++) {

canvas.save();

drawScene(canvas, paint, i);

canvas.restore();

}

}

private void drawScene(Canvas canvas, Paint paint, int idx) {

canvas.clipPath(mPath[idx]);

canvas.drawColor(Color.GRAY);

if (mBmpFlag[idx]) {

canvas.drawBitmap(mBmp[idx], mPathLT[idx][0] + mPathOffsetX + mPathOffset[idx][0], mPathLT[idx][1] + mPathOffsetY + mPathOffset[idx][1], paint);

} else {

canvas.drawBitmap(mBmp[idx], mPathLT[idx][0] + mPathOffset[idx][0], mPathLT[idx][1] + mPathOffset[idx][1], paint);

}

}

float ptx, pty;

float mPathOffsetX, mPathOffsetY;

@Override

public boolean onTouchEvent(MotionEvent event) {

switch (event.getAction()) {

case MotionEvent.ACTION_DOWN:

for (int i = 0; i < mPathNum; i++) {

mBmpFlag[i] = false;

}

ptx = event.getRawX();

pty = event.getRawY();

mPathOffsetX = 0;

mPathOffsetY = 0;

int cflag = 0;

for (cflag = 0; cflag < mPathNum; cflag++) {

if (contains(mPath[cflag], ptx, pty)) {

mBmpFlag[cflag] = true;

break;

}

}

break;

case MotionEvent.ACTION_MOVE:

mPathOffsetX = event.getRawX() - ptx;

mPathOffsetY = event.getRawY() - pty;

invalidate();

break;

case MotionEvent.ACTION_UP:

for (int i = 0; i < mPathNum; i++) {

if (mBmpFlag[i]) {

mPathOffset[i][0] += event.getRawX() - ptx;

mPathOffset[i][1] += event.getRawY() - pty;

if (mPathOffset[i][0] < 0) {

mPathOffset[i][0] = 0;

}

if (mPathOffset[i][0] > (mBmp[i].getWidth() - viewWdh)) {

mPathOffset[i][0] = (mBmp[i].getWidth() - viewWdh);

}

if (mPathOffset[i][1] > 0) {

mPathOffset[i][1] = 0;

}

if (mPathOffset[i][1] < -(mBmp[i].getHeight() - itemHgt)) {

mPathOffset[i][1] = -(mBmp[i].getHeight() - itemHgt);

}

mBmpFlag[i] = false;

break;

}

}

invalidate();

break;

default:

break;

}

return true;

}

private boolean contains(Path paramPath, float pointx, float pointy)

{

RectF localRectF = new RectF();

paramPath.computeBounds(localRectF, true);

Region localRegion = new Region();

localRegion.setPath(paramPath, new Region((int)localRectF.left, (int)localRectF.top, (int)localRectF.right, (int)localRectF.bottom));

return localRegion.contains((int)pointx, (int)pointy);

}

}

还有哪些P图软件可以弄背景

功能最强大的当然是Photoshop。它可以更换得毫无痕迹。

这是什么软件设计的原理图

通过CAD 关于电力的更多

是 orCAD capture cis lite 吗

orCAD里面的电阻不是这样的呀

是的 电阻有很多种的

6:8F 是什么呢？ 输入信号吗？

有什么P图软件可以把衣服裤子P没的吗？求大神

是要一键P成果体吗？

小伙子你的想法hin大胆啊！

软件没有，只能人工。

不过有类似的手机APP

撕衣服的，原理是有两张照片叠在一起，一张穿的一张没穿的，手在上面涂抹可以把没穿衣服的那张撕掉就成没穿的了，希望帮到你哦~更多

怎么弄啊不明白

意思就是你要找一张果体照片，而且要与你想P掉衣服的那张照片的角度动作类似

使用PS对好位置调色，盖在上面就行了。

类似贴画，白墙上贴层红纸看起来就像是红墙了，懂了吗？

PS软件可以做到多个图层叠加在一起，如果还是不懂的话建议去了解一下PS的工作方式

喔喔

请问有什么软件可以这么p图的？

这可以使用Pixlr的双重曝光制作

在砖墙上添加人像后选择混合中的正片叠底

软件名字叫什么？最好有个图标

Pixlr

谢谢

为啥在app找不到这个软件？

美图秀秀的美颜相机什么原理？对手机自身系统自带的相机或硬件设备有什么不好的影响吗？

美颜相机的原理，就是拍照后在手机内对照片做软件后期处理，和拍照后在电脑上ps一样的道理，对硬件不可能产生任何影响

不同的相机软件拍照都是调用系统软件接口控制摄像头，但是不同软件对照片的保存压缩率可能是不同的，对图像的后期处理也会导致画质下降

下载了美颜相机后画质变差（像素变差这样的说法非常不准确），可能和软件保存处理照片有关，只要原相机软件拍照不变就没问题

如果原始相机软件拍照也变差了，那么多半就是你的心理错觉了

谁知道有什么P图软件是可以把字和照片消除的

选择修补工具，把文字圈起来，如下图：

2、使用鼠标，把选区拉向右边。如下图：

3、效果如下图：

修补工具的原理是：利用相似图像作为补丁来修补，从而达到修复图像的目的。

转载请注明出处51数据库 » p图软件原理 美图秀秀的工作原理是什么