IT瘾照片推荐

8个常用技巧，让你的照片有效的突出主体_对比

Mon, 26 Dec 2022 14:45:52 CST

大量的留白，简洁的画面，大大小小的渔船如同水写意一样。

人像的拍摄，常选用大光圈使得背景虚化，人物主体得到很好地突出。

使用慢门，将画面的背景简化，使主体更加突出。

利用光与影，形成明暗对比以突出主体，增加画面的立体感与空间感的同时，使背景简洁。

剪影化处理，突出主体。

TIPS：裁剪与留白同样重要，在比较杂乱的环境中主要考虑遮挡构图，在比较简单的环境中多用裁剪，从而增加构图的多样性和可赏性。

2、对比

为画面制造出对比与冲突是摄影者常用的突出主体的手法之一。没有形式上的对比，照片缺少吸引观者的兴趣点，显得画面乏味。没有内涵上的冲突，照片难以引发读者的思考，让人过目即忘。

右侧的冷色和暗调，与左方的暖色和亮调，形成了强烈的对比，牢牢的抓住了观者的眼球。

人与自然在内容上形成的对比，充满了喜剧般的张力的同时，又引发观者深思。

形式上的对比，也就是画面上的对比，比如大小、明暗、冷暖等等，让画面充满了表现力，吸引读者的目光；内涵上的对比，也就是内容上的对比，比如战争与和平，人类与自然，悲伤和喜悦等等，则让照片充满了戏剧张力，引起观者的思考。

虚化的、流动的车流与实体的景物形成了虚实对比，动静对比，增强了画面视觉冲击力。

蜻蜓与荷花，一动一静形成了趣味性的对比，为画面增添了活力与趣味。

对比在我们生活中也无处不在，如鲜花与绿叶，就会互相衬托；还有高楼和茅草屋的对比，天鹅与青蛙的对比等。在摄影创作中，常见的对比手法有：虚实对比、明暗对比、远近对比、大小对比、色彩对比、动静对比等。

摄影：Max Rive

TIPS：很多的好照片更是两者兼备，比如Max Rive的这张经典作品，画面中冷暖、明暗、大小的形式冲突，大大提高了画面的表现力。而其中表现的人类与自然的内涵对比，更加强化了照片的震撼程度。

3、构图

一幅成功的摄影作品，首先是构图的成功。成功的构图能使作品内容顺理成章，主次分明，主题突出，赏心悦目。反之，构图没有章法，缺乏层次，整幅作品不知所云。可见好的构图自然突出主体。

镜头前面的景物彻底虚化成团具有色调的虚影，渲染氛围，同时作为画面点缀以突出人物主体。

公路巧妙地分割画面，其实它还是视觉引导线，从近端引导读者的视线到拍摄主体雪山上。

蜻蜓与一片黄叶在干净的背景上形成了两点构图。一主一次。

被摄主体放置画面的正中央，将大家的视线集中到被摄主体上。

暗调的部分做了简化处理的同时，与亮部的主体作为鲜明的对比以突出亮部主体。

4、色彩搭配

色彩作为摄影创作不可或缺的元素，在摄影中，除了构图和光影外，最影响照片美观的就是色彩了。俗话说，“红花虽好，尚需绿叶相扶”，就精辟地说明了色彩的作用。在一幅作品中，色彩鲜明的景物总是能很快抓住人们的眼球。在拍摄时，可以充分利用主陪体之间鲜明的色彩对比，有效地突出画面的主体。

不同明度的红色枫叶，突出了画面的主体。

天空的蓝色和油菜花的黄色对比，突出了油菜花的主体。

TIPS：如果只是寄希望于自然界提供的同类色，创作思路还是显得窄了些。通过摄影技巧，有意地将原本不能同时出现的同类色组合使用，则更高明一些。

5、通过陪体突出主体

在电影和电视剧中，配角所占的地位不可小觑，对整个故事和主角起着补充的作用。同样，在摄影中，陪体也发挥着进一步强调主体的作用。那么在摄影创作中，如何利用陪体来强调主体呢？

在油菜花田里加入了一个曼妙的身影，画面就会变得更加美丽，照片更有想象的空间。

可参见前文

摄影丨摄影作品中，如何利用陪体强调主体？

6、角度

改变拍摄角度，也是一个突出主体的有效尝试。如低视角仰拍，在突出主体的同时，背景则会相对缩小，还能很好地表现出空间感；又如俯拍，可以收获不同于平常的画面效果，有时反而可以让主体从周围环境中脱颖而出。

（左：拍摄效果图右：场景图）人满为患的南京夫子庙，低角度避开杂乱的人群。

高处俯拍风光，表现出地面景物的纵深、数量和层次感，也避开了人群的干扰。

如果无论怎么取景都不满意，不如试试拍特写吧，局部虽不如整体大气，但“留白式”的拍摄手法也会留给人更多想象空间。

大家对故宫的普遍印象就是磅礴大气，而这组门把手的的细节拍摄，则表现出了故宫历史沉静的另外一面。

7、二次构图

二次构图就是在照片的基础上继续构图，通常通过图像处理软件对原有照片进行必要的增删改，以达到理想的构图。具体方法包括：裁剪、变换构图、矫正构图、祛除冗余构图、扩大构图、创意构图等。二次构图最常见画幅类型有：长方形画幅、方形画幅、立轴、宽画幅、圆形画幅、扇面等。

构图与虚化都较好的作品，如果再仔细推磨，经过旋转和校正，可以从中提取出主体更突出，画面更动感的作品。

从竖构图到方构图的改变，使观者的视线更好地聚焦在主体上。

TIPS：尽管二次构图可以对照片进行一些构图上的调整和完善，但或多或少都会影响照片的画质，所以在前期拍摄的时候，我们要多一些思考少一点随意，构图上尽量一次到位的好。

8、后期

通过Photoshop、Lightroom等图片编辑软件，对照片进行后期处理，从而更为精准地突出主体，更为完美地表现主题。较为常用的方法有：背景模糊法、聚光效果、主体放大法、色彩引导法、轮廓线条图示法、局部淡化法、裁剪配色法、线条引导法等。

经过Photoshop处理后如下图，主体明显更突出。

包围曝光+HDR合成，有效地突出主体。

总结

主体服务于主题，场景服务于主体，构图服务于场景，找到你想要表现的主体元素，最大程度地展现出来。一般情况下，使用上述所列的2种或2种以上的方法，综合运用，从而更有力地实现突出主体的目标。

使用tess4j完成身份证和营业执照图片的文字识别 - Mr.Simm - 博客园

Tue, 25 Aug 2020 21:27:00 CST

这两天研究了一下关于OCR图文解析的技术。当然市场上已经有开源服务，比如百度的AI开放平台，就有OCR相关的API接口。我这里选用的是Tesseract开源框架，java封装版本是tess4j。结合网上公布的一些开源项目提供的demo，完成了身份证与营业执照的相关文字识别的处理。总体上来讲Tesseract其实还不错，简单应用其实还挺简单的（提供的图片质量可以靠前端做好限制，比如身份证识别，加上头像或国徽的框图限定，能提高识别率）。

　　示例项目地址： https://github.com/git-simm/simm-framework

一、技术介绍

OCR(Optical Character Recognition)：光学字符识别，是指电子设备（例如扫描仪或数码相机）检查纸上打印的字符，通过检测暗、亮的模式确定其形状，然后用字符识别方法将形状翻译成计算机文字的过程。
Tesseract：开源的OCR识别引擎，初期Tesseract引擎由HP实验室研发，后来贡献给了开源软件业，后由Google进行改进、修改bug、优化，重新发布。

　　Tess4J：是对Tesseract OCR API.的Java JNA 封装。使java能够通过调用Tess4J的API来使用Tesseract OCR。支持的格式：TIFF,JPEG,GIF,PNG,BMP,JPEG,and PDF

Tess4J API 提供的功能：
1、直接识别支持的文件
2、识别图片流
3、识别图片的某块区域
4、将识别结果保存为 TEXT/ HOCR/ PDF/ UNLV/ BOX
5、通过设置取词的等级，提取识别出来的文字
6、获得每一个识别区域的具体坐标范围
7、调整倾斜的图片
8、裁剪图片
9、调整图片分辨率
10、从粘贴板获得图像
11、克隆一个图像（目的：创建一份一模一样的图片，与原图在操作修改上，不相互影响）
12、图片转换为二进制、黑白图像、灰度图像
13、反转图片颜色

二 、环境准备( https://www.jianshu.com/p/ef60ef5395c5)

　　2.1、我们需要安装tessdata语言包，用于图文识别。 tesseract-ocr语言包的下载地址，用于识别文字时进行匹配。链接: https://pan.baidu.com/s/1XAvPkTdUXuFq-q2InDREhQ 提取码: 6vjp

　　2.2、项目引入maven依赖

<dependency>
            <groupId>net.sourceforge.tess4j</groupId>
            <artifactId>tess4j</artifactId>
            <version>4.5.2</version>
        </dependency>

三 、简单描述下图文解析的过程

四 、服务端关键代码的展示

private static int targetBrightness = 260;
    private static int targetDifferenceValue = 15;

    /**
     * 解析身份证信息
     *
     * @param inputStream
     * @return
     * @throws Exception
     */
    @Override
    public BizLicenseInfo getInfo(InputStream inputStream) throws Exception {
        BizLicenseInfo bizLicenseInfo = new BizLicenseInfo();
        String rootPath = ClassUtils.getDefaultClassLoader().getResource("").getPath()+"/tmp";
        Tesseract tesseract = new Tesseract();
        tesseract.setLanguage("chi_sim");
        //读取网络图片
        BufferedImage bufferedImage = ImageFilter.cloneImage(ImageIO.read(inputStream));
        //不过滤部分颜色
        //bufferedImage = ImageFilter.imageRGBDifferenceFilter(bufferedImage, targetDifferenceValue, null);
        bufferedImage = ImageFilter.convertImageToGrayScale(bufferedImage);
        //缩放到真实身份证大小
        bufferedImage = ImageFilter.imageScale(bufferedImage, 3150, 1920);
        try (OutputStream outputStream = new FileOutputStream(rootPath+"/bg.jpg")) {
            saveImg(bufferedImage,outputStream);
            getBufferedNameImage(tesseract, bufferedImage, bizLicenseInfo,rootPath+"/nameImageBefore.jpg");
            getBufferedCapitalImage(tesseract, bufferedImage, bizLicenseInfo,rootPath+"/capitalImageBefore.jpg");
            getBufferedBizTypeImage(tesseract, bufferedImage, bizLicenseInfo,rootPath+"/bizTypeImageBefore.jpg");
            getBufferedBuildOnImage(tesseract, bufferedImage, bizLicenseInfo,rootPath+"/buildOnImageBefore.jpg");
            getBufferedJuridicalImage(tesseract, bufferedImage, bizLicenseInfo,rootPath+"/juridicalImageBefore.jpg");
            getBufferedBizLimitImage(tesseract, bufferedImage, bizLicenseInfo,rootPath+"/bizLimitImageBefore.jpg");
            getBufferedBizScopeImage(tesseract, bufferedImage, bizLicenseInfo,rootPath+"/bizScopeImageBefore.jpg");
            getBufferedAddressImage(tesseract, bufferedImage, bizLicenseInfo,rootPath+"/addressImageBefore.jpg");
            getBufferedCreditCodeImage(tesseract, bufferedImage, bizLicenseInfo,rootPath+"/creditCodeImageBefore.jpg");
            return bizLicenseInfo;
        }catch (Exception e){
            e.printStackTrace();
            throw e;
        }
    }

/**
     * 获取统一社会信用代码
     * @param tesseract
     * @param bufferedImage
     * @param bizLicenseInfo
     * @param path
     * @throws IOException
     * @throws TesseractException
     */
    private void getBufferedCreditCodeImage(Tesseract tesseract, BufferedImage bufferedImage, BizLicenseInfo bizLicenseInfo, String path) throws IOException, TesseractException {
        try (OutputStream outputStream = new FileOutputStream(path)) {
            BufferedImage idImage = ImageFilter.subImage(bufferedImage, bufferedImage.getMinX() + 200
                    , 250, 550, 300);
            System.out.println("creditCodeImage 辉度处理");
            handBrightness(idImage, targetBrightness);
            saveImg(idImage, outputStream);
//            tesseract.setLanguage("eng");
            tesseract.setLanguage("chi_sim");
            // \W 可以配置 非字母和数字，等价于 [^a-zA-Z0-9] (\d \D 小写表示匹配数字，大写表示匹配非数字)
            String idCardNumber = tesseract.doOCR(idImage).replaceAll("[\\W]", "");
            bizLicenseInfo.setCreditCode(idCardNumber);
        }catch (Exception e){
            e.printStackTrace();
            throw e;
        }
    }

    /**
     * 获取名称
     * @param tesseract
     * @param bufferedImage
     * @param bizLicenseInfo
     * @param path
     */
    private void getBufferedNameImage(Tesseract tesseract, BufferedImage bufferedImage, BizLicenseInfo bizLicenseInfo, String path) throws IOException, TesseractException {
        BufferedImage buffered = ImageFilter.subImage(bufferedImage, 520, 700, 1200, 120);
        getBufferedImage(tesseract,buffered,path,(img,content)->{
            System.out.println("setName 辉度处理");
            bizLicenseInfo.setName(content);
        });
    }
    /**
     * 获取类型
     * @param tesseract
     * @param bufferedImage
     * @param bizLicenseInfo
     * @param path
     * @throws IOException
     * @throws TesseractException
     */
    private void getBufferedBizTypeImage(Tesseract tesseract, BufferedImage bufferedImage, BizLicenseInfo bizLicenseInfo, String path) throws IOException, TesseractException {
        BufferedImage buffered = ImageFilter.subImage(bufferedImage, 520, 820, 1200, 130);
        getBufferedImage(tesseract,buffered,path,(img,content)->{
            System.out.println("setBizType 辉度处理");
            bizLicenseInfo.setBizType(content);
        });
    }
    /**
     * 获取法人信息
     * @param tesseract
     * @param bufferedImage
     * @param bizLicenseInfo
     * @param path
     * @throws IOException
     * @throws TesseractException
     */
    private void getBufferedJuridicalImage(Tesseract tesseract, BufferedImage bufferedImage, BizLicenseInfo bizLicenseInfo, String path) throws IOException, TesseractException {
        BufferedImage buffered = ImageFilter.subImage(bufferedImage, 520, 950, 1200, 120);
        getBufferedImage(tesseract,buffered,path,(img,content)->{
            System.out.println("setJuridical 辉度处理");
            bizLicenseInfo.setJuridical(content);
        });
    }

    /**
     * 获取经营范围
     * @param tesseract
     * @param bufferedImage
     * @param bizLicenseInfo
     * @param path
     * @throws IOException
     * @throws TesseractException
     */
    private void getBufferedBizScopeImage(Tesseract tesseract, BufferedImage bufferedImage, BizLicenseInfo bizLicenseInfo, String path) throws IOException, TesseractException {
        BufferedImage buffered = ImageFilter.subImage(bufferedImage, 520, 1070, 1330, bufferedImage.getHeight() - 1200);
        getBufferedImage(tesseract,buffered,path,(img,content)->{
            System.out.println("setBizScope 辉度处理");
            bizLicenseInfo.setBizScope(content);
        });
    }

    /**
     * 获取注册资本
     * @param tesseract
     * @param bufferedImage
     * @param bizLicenseInfo
     * @param path
     * @throws IOException
     * @throws TesseractException
     */
    private void getBufferedCapitalImage(Tesseract tesseract, BufferedImage bufferedImage, BizLicenseInfo bizLicenseInfo, String path) throws IOException, TesseractException {
        BufferedImage buffered = ImageFilter.subImage(bufferedImage, 2170, 720, bufferedImage.getWidth()-2400, 120);
        getBufferedImage(tesseract,buffered,path,(img,content)->{
            System.out.println("setCapital 辉度处理");
            bizLicenseInfo.setCapital(content);
        });
    }

    /**
     * 获取成立日期
     * @param tesseract
     * @param bufferedImage
     * @param bizLicenseInfo
     * @param path
     * @throws IOException
     * @throws TesseractException
     */
    private void getBufferedBuildOnImage(Tesseract tesseract, BufferedImage bufferedImage, BizLicenseInfo bizLicenseInfo, String path) throws IOException, TesseractException {
        BufferedImage buffered = ImageFilter.subImage(bufferedImage, 2170, 850, bufferedImage.getWidth()-2400, 100);
        getBufferedImage(tesseract,buffered,path,(img,content)->{
            System.out.println("setBuildOn 辉度处理");
            bizLicenseInfo.setBuildOn(content);
        });
    }

    /**
     * 获取营业期限
     * @param tesseract
     * @param bufferedImage
     * @param bizLicenseInfo
     * @param path
     * @throws IOException
     * @throws TesseractException
     */
    private void getBufferedBizLimitImage(Tesseract tesseract, BufferedImage bufferedImage, BizLicenseInfo bizLicenseInfo, String path) throws IOException, TesseractException {
        BufferedImage buffered = ImageFilter.subImage(bufferedImage, 2170, 970, bufferedImage.getWidth()-2400, 100);
        getBufferedImage(tesseract,buffered,path,(img,content)->{
            System.out.println("setBizLimit 辉度处理");
            bizLicenseInfo.setBizLimit(content);
        });
    }

    /**
     * 获取住所
     * @param tesseract
     * @param bufferedImage
     * @param bizLicenseInfo
     * @param path
     * @throws IOException
     * @throws TesseractException
     */
    private void getBufferedAddressImage(Tesseract tesseract, BufferedImage bufferedImage, BizLicenseInfo bizLicenseInfo, String path) throws IOException, TesseractException {
        BufferedImage buffered = ImageFilter.subImage(bufferedImage, 2170, 1070, bufferedImage.getWidth()-2240, 270);
        getBufferedImage(tesseract,buffered,path,(img,content)->{
            System.out.println("setAddress 辉度处理");
            bizLicenseInfo.setAddress(content);
        });
    }
    /**
     * 获取名称
     * @param tesseract
     * @param buffered
     * @param path
     * @param consumer
     */
    private void getBufferedImage(Tesseract tesseract, BufferedImage buffered, String path, BiConsumer<BufferedImage,String> consumer) throws IOException, TesseractException {
        try (OutputStream outputStream = new FileOutputStream(path)) {
//            addressImage = ImageFilter.imageScale(addressImage, ((int) (addressImage.getWidth() * 2.4) + 1), ((int) (addressImage.getHeight() * 2.4) + 1));
            handBrightness(buffered, targetBrightness);
            saveImg(buffered, outputStream);
            tesseract.setLanguage("chi_sim");
            String result = tesseract.doOCR(buffered);
            //留下中文字符、中文标点符号（）【】、
            String regexStr = "[^\\s\\u4e00-\\u9fa5\\(\\)\\uff08\\uff09\\u3001\\u3010\\u3011\\-0-9]+";
            String content = result.replaceAll(regexStr, "")
                    .replaceAll("\\n", "")
                    .replaceAll(" ", "");
            if(consumer!=null){
                consumer.accept(buffered,content);
            }
        }catch (Exception e){
            e.printStackTrace();
            throw e;
        }
    }
    /**
     * 保存图片
     * @param image
     * @param outputStream
     * @throws IOException
     */
    private void saveImg(BufferedImage image,OutputStream outputStream) throws IOException {
        ImageIO.write(image, "jpg", outputStream);
    }
    /**
     * 处理图片辉度
     *
     * @param subImage
     */
    private void handBrightness(BufferedImage subImage, int targetBrightness) {
        int fixedBrightness;
        int birthBrightness = ImageFilter.imageBrightness(subImage);
        System.out.println("brightness = " + birthBrightness);
        fixedBrightness = targetBrightness - birthBrightness;
        //辉度处理
        if (fixedBrightness != 0) {
            subImage = ImageFilter.imageBrightness(subImage, fixedBrightness);
        }
        System.out.println("after brightness = " + ImageFilter.imageBrightness(subImage));
    }

五 、解析效果展示

　　5.1、身份证信息识别示例：

　　5.2、营业执照信息识别示例：

参考资料：

https://github.com/firefoxmmx2/IDCardIDentify

https://www.jianshu.com/p/e7915ba6f0e7

https://kefeng.wang/2017/04/22/tess4j/

中国移动科普：手机里的身份证照片应果断删除

Fri, 04 Jan 2019 19:40:48 CST

一个手机号、一台能上网的智能手机，仅靠这两样，在当下的社会生活中就能办成各种各样的事情，包括一些敏感的、数额不小的金融活动。1月4日，中国移动10086官方微博发布科普一张图， 提醒手机里存有身份证等个人隐私照片的朋友，果断删除，以免留下后患。

官方引述的例子是，李某打开存有赵先生身份证照片的手机相册后，利用这个不起眼的疏漏修改了失主的支付宝账号，刷走余额2000余元，甚至连花呗、借呗也没放过进行透支购物，最后还把手机折现千元，给对方造成了不小的损失。

86君另外提醒，除了身份证，账户密码、手机验证码、Apple ID/密码、各类单据、定位信息、各类证件复印件（书写进攻xx使用等）等类似的隐私信息都要留心保护好，以策万全。

英国警方的图像识别软件无法区分裸照和沙漠照片

Sun, 24 Dec 2017 23:01:11 CST

在英国，持有儿童色情是一项重罪。从扣押的设备寻找定罪证据显然不能靠人工一个个文件夹查。伦敦警察厅的数字取证部门使用图像识别软件去搜索设备。它去年搜索了 5.3 万个设备。但它的图像识别软件不足够先进，甚至无法区分裸照和沙漠照片，因此会把计算机上的沙漠屏保识别为皮肤颜色，而众所周知 Windows 的一个著名屏保就是沙漠图像。英国警方准备求助于互联网巨头，利用亚马逊或 Google 或微软云计算服务提供的庞大算力来分析图像和视频。警方数字取证部门的主管认为在两到三年内训练有素的 AI 将能识别出儿童色情。

android 端拍照并运用Tesseract OCR 识别图片中字符

Tue, 24 May 2016 22:32:26 CST

借鉴了一篇博客：
http://my.oschina.net/yushulx/blog/359468#OSC_h3_4

英文版在这里：

http://www.codepool.biz/making-an-android-ocr-application-with-tesseract.html

我上传了一个android studio环境下的例子，可以拍照或者选择图库中图片进行识别。

这个链接（）包括一份工程源代码和两个压缩包（语言包），一个是中文汉字，一个是英文。

请注意：

必须现在手机内部存储根目录

(在程序中获取这个字符串就明白这个目录是什么了Environment.getExternalStorageDirectory())

下新建一个文件夹tessdata，然后把语言包解压后放进这个目录，如果没有语言包，程序会崩溃。

程序并不是特别精确，因为是直接识别的，没有对图片进行处理，我会在稍后的博客里讲述如何处理图片(比图锐化等)以提高精确度。

已有 0 人发表留言，猛击->> 这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

照片批量压缩和修改大小的命令

Sat, 12 Sep 2015 23:05:26 CST

单反相机里存了越来越多的照片，每张大约 3-5 MB 左右，最近想怎么快捷的将照片转换成 WEB 可分享的格式，可以方便的发给其他人。当然，可以用 PS 或者其他图片处理工具。但是还是喜欢命令行的简单可高、高效。发现 2 个 UNIX 相关命令就可以快速搞定这个需求。

jpegoptim 用来压缩图片的大小，可以设置保真度。
sips 用来快速调整图片大小。

一般将需要处理的文件放到一个文件夹，然后执行两个命令即可：

find . -iname "*.jpg" -exec jpegoptim -m80 -o -p {} \;
sips -Z 1024 *.jpg

处理过程：

➜  blog-photo  ll
total 37976
-rwxrwxrwx@ 1 Bruce  staff   3.1M Dec  1  2013 IMG_1483.JPG
-rwxrwxrwx@ 1 Bruce  staff   2.2M Dec  1  2013 IMG_1531.JPG
-rwxrwxrwx@ 1 Bruce  staff   5.1M May  3  2014 IMG_1546.JPG
-rwxrwxrwx@ 1 Bruce  staff   4.8M May  3  2014 IMG_1556.JPG
-rwxrwxrwx@ 1 Bruce  staff   3.3M Aug 28  2014 IMG_1795.JPG
➜  blog-photo  find . -iname "*.jpg" -exec jpegoptim -m80 -o -p {} \;
./IMG_1483.JPG 3456x2304 24bit N Exiff XMP  [OK] 3252270 --&gt; 951224 bytes (70.75%), optimized.
./IMG_1531.JPG 3456x2304 24bit N Exiff XMP  [OK] 2255669 --&gt; 499200 bytes (77.87%), optimized.
./IMG_1546.JPG 3456x2304 24bit N Exiff XMP  [OK] 5388994 --&gt; 1668661 bytes (69.04%), optimized.
./IMG_1556.JPG 3456x2304 24bit N Exiff XMP  [OK] 5038732 --&gt; 1580830 bytes (68.63%), optimized.
./IMG_1795.JPG 3456x2304 24bit N Exiff XMP  [OK] 3497537 --&gt; 920324 bytes (73.69%), optimized.
➜  blog-photo  sips -Z 1024 *.JPG
/Users/Bruce/Desktop/blog-photo/IMG_1483.JPG
[ (kCGColorSpaceDeviceRGB)] ( 0 0 0 1 )
/Users/Bruce/Desktop/blog-photo/IMG_1483.JPG
/Users/Bruce/Desktop/blog-photo/IMG_1531.JPG
[ (kCGColorSpaceDeviceRGB)] ( 0 0 0 1 )
/Users/Bruce/Desktop/blog-photo/IMG_1531.JPG
/Users/Bruce/Desktop/blog-photo/IMG_1546.JPG
[ (kCGColorSpaceDeviceRGB)] ( 0 0 0 1 )
/Users/Bruce/Desktop/blog-photo/IMG_1546.JPG
/Users/Bruce/Desktop/blog-photo/IMG_1556.JPG
[ (kCGColorSpaceDeviceRGB)] ( 0 0 0 1 )
/Users/Bruce/Desktop/blog-photo/IMG_1556.JPG
/Users/Bruce/Desktop/blog-photo/IMG_1795.JPG
[ (kCGColorSpaceDeviceRGB)] ( 0 0 0 1 )
/Users/Bruce/Desktop/blog-photo/IMG_1795.JPG
➜  blog-photo  ll
total 2240
-rw-r--r--  1 Bruce  staff   187K Sep 12 15:53 IMG_1483.JPG
-rw-r--r--  1 Bruce  staff   127K Sep 12 15:53 IMG_1531.JPG
-rw-r--r--  1 Bruce  staff   313K Sep 12 15:53 IMG_1546.JPG
-rw-r--r--  1 Bruce  staff   308K Sep 12 15:53 IMG_1556.JPG
-rw-r--r--  1 Bruce  staff   177K Sep 12 15:53 IMG_1795.JPG

可以看到所有照片大小都变成了 100-300 KB 。这是处理后的效果：

以后处理单反相机里的照片就方便了，将照片复制到一个文件夹，执行 2 个命令即可。

法国家长把宝宝照片放在Facebook上将面临坐牢和罚款

Mon, 09 May 2016 00:40:46 CST

法国执法机构已经警告父母，如果他们在Facebook上发布家中幼儿照片，将面临罚款和坐牢的惩罚。根据法国严格的隐私法，法国当局已经表示，如果家长把未成年孩子照片暴露在互联网上，将面临高达45000欧元的罚款和一年有期徒刑。根据法国的隐私法，在短短几年内，孩子们可以很容易地把他们的父母告上法院，因为他们在孩子年轻的时候公布孩子的照片。

我们都知道家长贴出这些未成年孩子照片之后，第三方有可能拿这些照片进行不可告人的危险行为。或者，在某些情况下，人们在Instagram上进行角色扮演父母，使用偷来的照片从事陌生的游戏。

法国的法律制定者对此已经制定了可谓严苛的法律来惩罚这些行为。已经上传照片的法国父母可以通过在社交网络当中删除已经上传的照片，或者删除它们的标签来避免被法律惩罚。

查看评论

安卓开发笔记——关于照片墙的实现（完美缓存策略LruCache+DiskLruCache） - Balla_兔子

Tue, 21 Apr 2015 01:53:00 CST

这几天一直研究在安卓开发中图片应该如何处理，在网上翻了好多资料，这里做点小总结，如果朋友们有更好的解决方案，可以留言一起交流下。

内存缓存技术

在我们开发程序中要在界面上加载一张图片是件非常容易的事情，但如果是加载一堆图片呢？比如ListView，GridView这类的控件，随着屏幕滑动，图片加载也会越来越多，应用程序所可以使用的内存毕竟是有限的，如果一味的去加载图片，很容易导致OOM（Out Of Memory）内存溢出，导致程序崩溃。

这里我们一般的做法是将显示在屏幕之外的图片进行内存回收，此时的垃圾回收器会认为应用对这些图片不再持有引用，从而进行GC操作。但现实还需要考虑到问题是，如果用户又滑动屏幕回到之前我们已经回收掉的图片位置，这时候该怎么办？重新去加载一张图片肯定是不可取的，这样既浪费了时间，又浪费了用户的流量。

这里我们就会想到利用内存缓存来解决这个问题，利用内存缓存可以让应用快速的加载和处理图片，从而提高流畅性。

内存缓存技术对那些大量占用应用程序宝贵内存的图片提供了快速访问的方法，其中最核心的类是LruCache (此类在android-support-v4的包中提供) 。这个类非常适合用来缓存图片，它的主要算法原理是把最近使用的对象用强引用存储在 LinkedHashMap 中，并且把最近最少使用的对象在缓存值达到预设定值之前从内存中移除。

在过去，我们经常会使用一种非常流行的内存缓存技术的实现，即软引用或弱引用 (SoftReference or WeakReference)。但是现在已经不再推荐使用这种方式了，因为从 Android 2.3 (API Level 9)开始，垃圾回收器会更倾向于回收持有软引用或弱引用的对象，这让软引用和弱引用变得不再可靠。另外，Android 3.0 (API Level 11)中，图片的数据会存储在本地的内存当中，因而无法用一种可预见的方式将其释放，这就有潜在的风险造成应用程序的内存溢出并崩溃。

对于LruCache类不熟悉的朋友可以看看这篇文章《 Android高效加载大图、多图解决方案，有效避免程序OOM》。

磁盘缓存技术

对于内存缓存LruCache只是管理了内存中图片的存储与释放，如果图片从内存中被移除的话，那么又需要从网络上重新加载一次图片，这显然非常耗时。对此，Google又提供了一套硬盘缓存的解决方案：DiskLruCache(非Google官方编写，但获得官方认证)。

关于磁盘缓存DisLruCache类不熟悉的朋友可以看看这篇文章的介绍《 Android DiskLruCache完全解析，硬盘缓存的最佳方案》　　

完美结合LruCache+DiskLruCache

首先先来看下实现效果：

这是一个很简单的布局，大布局是GridView，小布局ImageView嵌套在大布局里，贴上代码再做分析吧，其实注释也挺全的。

既然要完成磁盘存储，那么必不可少的就是DisLruCache类的，先引进项目里再说，再来就是图片资源集合了。

图片资源类：

1 package com.example.photoswall;
2
3
4 /**
5 * 图片资源类
6 * @author Balla_兔子
7 *
8 */
9 public class Images {
10
11 public final static String[] imageThumbUrls = new String[] {
12 "http://img.my.csdn.net/uploads/201407/26/1406383299_1976.jpg",
13 "http://img.my.csdn.net/uploads/201407/26/1406383291_6518.jpg",
14 "http://img.my.csdn.net/uploads/201407/26/1406383291_8239.jpg",
15 "http://img.my.csdn.net/uploads/201407/26/1406383290_9329.jpg",
16 "http://img.my.csdn.net/uploads/201407/26/1406383290_1042.jpg",
17 "http://img.my.csdn.net/uploads/201407/26/1406383275_3977.jpg",
18 "http://img.my.csdn.net/uploads/201407/26/1406383265_8550.jpg",
19 "http://img.my.csdn.net/uploads/201407/26/1406383264_3954.jpg",
20 "http://img.my.csdn.net/uploads/201407/26/1406383264_4787.jpg",
21 "http://img.my.csdn.net/uploads/201407/26/1406383264_8243.jpg",
22 "http://img.my.csdn.net/uploads/201407/26/1406383248_3693.jpg",
23 "http://img.my.csdn.net/uploads/201407/26/1406383243_5120.jpg",
24 "http://img.my.csdn.net/uploads/201407/26/1406383242_3127.jpg",
25 "http://img.my.csdn.net/uploads/201407/26/1406383242_9576.jpg",
26 "http://img.my.csdn.net/uploads/201407/26/1406383242_1721.jpg",
27 "http://img.my.csdn.net/uploads/201407/26/1406383219_5806.jpg",
28 "http://img.my.csdn.net/uploads/201407/26/1406383214_7794.jpg",
29 "http://img.my.csdn.net/uploads/201407/26/1406383213_4418.jpg",
30 "http://img.my.csdn.net/uploads/201407/26/1406383213_3557.jpg",
31 "http://img.my.csdn.net/uploads/201407/26/1406383210_8779.jpg",
32 "http://img.my.csdn.net/uploads/201407/26/1406383172_4577.jpg",
33 "http://img.my.csdn.net/uploads/201407/26/1406383166_3407.jpg",
34 "http://img.my.csdn.net/uploads/201407/26/1406383166_2224.jpg",
35 "http://img.my.csdn.net/uploads/201407/26/1406383166_7301.jpg",
36 "http://img.my.csdn.net/uploads/201407/26/1406383165_7197.jpg",
37 "http://img.my.csdn.net/uploads/201407/26/1406383150_8410.jpg",
38 "http://img.my.csdn.net/uploads/201407/26/1406383131_3736.jpg",
39 "http://img.my.csdn.net/uploads/201407/26/1406383130_5094.jpg",
40 "http://img.my.csdn.net/uploads/201407/26/1406383130_7393.jpg",
41 "http://img.my.csdn.net/uploads/201407/26/1406383129_8813.jpg",
42 "http://img.my.csdn.net/uploads/201407/26/1406383100_3554.jpg",
43 "http://img.my.csdn.net/uploads/201407/26/1406383093_7894.jpg",
44 "http://img.my.csdn.net/uploads/201407/26/1406383092_2432.jpg",
45 "http://img.my.csdn.net/uploads/201407/26/1406383092_3071.jpg",
46 "http://img.my.csdn.net/uploads/201407/26/1406383091_3119.jpg",
47 "http://img.my.csdn.net/uploads/201407/26/1406383059_6589.jpg",
48 "http://img.my.csdn.net/uploads/201407/26/1406383059_8814.jpg",
49 "http://img.my.csdn.net/uploads/201407/26/1406383059_2237.jpg",
50 "http://img.my.csdn.net/uploads/201407/26/1406383058_4330.jpg",
51 "http://img.my.csdn.net/uploads/201407/26/1406383038_3602.jpg",
52 "http://img.my.csdn.net/uploads/201407/26/1406382942_3079.jpg",
53 "http://img.my.csdn.net/uploads/201407/26/1406382942_8125.jpg",
54 "http://img.my.csdn.net/uploads/201407/26/1406382942_4881.jpg",
55 "http://img.my.csdn.net/uploads/201407/26/1406382941_4559.jpg",
56 "http://img.my.csdn.net/uploads/201407/26/1406382941_3845.jpg",
57 "http://img.my.csdn.net/uploads/201407/26/1406382924_8955.jpg",
58 "http://img.my.csdn.net/uploads/201407/26/1406382923_2141.jpg",
59 "http://img.my.csdn.net/uploads/201407/26/1406382923_8437.jpg",
60 "http://img.my.csdn.net/uploads/201407/26/1406382922_6166.jpg",
61 "http://img.my.csdn.net/uploads/201407/26/1406382922_4843.jpg",
62 "http://img.my.csdn.net/uploads/201407/26/1406382905_5804.jpg",
63 "http://img.my.csdn.net/uploads/201407/26/1406382904_3362.jpg",
64 "http://img.my.csdn.net/uploads/201407/26/1406382904_2312.jpg",
65 "http://img.my.csdn.net/uploads/201407/26/1406382904_4960.jpg",
66 "http://img.my.csdn.net/uploads/201407/26/1406382900_2418.jpg",
67 "http://img.my.csdn.net/uploads/201407/26/1406382881_4490.jpg",
68 "http://img.my.csdn.net/uploads/201407/26/1406382881_5935.jpg",
69 "http://img.my.csdn.net/uploads/201407/26/1406382880_3865.jpg",
70 "http://img.my.csdn.net/uploads/201407/26/1406382880_4662.jpg",
71 "http://img.my.csdn.net/uploads/201407/26/1406382879_2553.jpg",
72 "http://img.my.csdn.net/uploads/201407/26/1406382862_5375.jpg",
73 "http://img.my.csdn.net/uploads/201407/26/1406382862_1748.jpg",
74 "http://img.my.csdn.net/uploads/201407/26/1406382861_7618.jpg",
75 "http://img.my.csdn.net/uploads/201407/26/1406382861_8606.jpg",
76 "http://img.my.csdn.net/uploads/201407/26/1406382861_8949.jpg",
77 "http://img.my.csdn.net/uploads/201407/26/1406382841_9821.jpg",
78 "http://img.my.csdn.net/uploads/201407/26/1406382840_6603.jpg",
79 "http://img.my.csdn.net/uploads/201407/26/1406382840_2405.jpg",
80 "http://img.my.csdn.net/uploads/201407/26/1406382840_6354.jpg",
81 "http://img.my.csdn.net/uploads/201407/26/1406382839_5779.jpg",
82 "http://img.my.csdn.net/uploads/201407/26/1406382810_7578.jpg",
83 "http://img.my.csdn.net/uploads/201407/26/1406382810_2436.jpg",
84 "http://img.my.csdn.net/uploads/201407/26/1406382809_3883.jpg",
85 "http://img.my.csdn.net/uploads/201407/26/1406382809_6269.jpg",
86 "http://img.my.csdn.net/uploads/201407/26/1406382808_4179.jpg",
87 "http://img.my.csdn.net/uploads/201407/26/1406382790_8326.jpg",
88 "http://img.my.csdn.net/uploads/201407/26/1406382789_7174.jpg",
89 "http://img.my.csdn.net/uploads/201407/26/1406382789_5170.jpg",
90 "http://img.my.csdn.net/uploads/201407/26/1406382789_4118.jpg",
91 "http://img.my.csdn.net/uploads/201407/26/1406382788_9532.jpg",
92 "http://img.my.csdn.net/uploads/201407/26/1406382767_3184.jpg",
93 "http://img.my.csdn.net/uploads/201407/26/1406382767_4772.jpg",
94 "http://img.my.csdn.net/uploads/201407/26/1406382766_4924.jpg",
95 "http://img.my.csdn.net/uploads/201407/26/1406382766_5762.jpg",
96 "http://img.my.csdn.net/uploads/201407/26/1406382765_7341.jpg"
97 };
98 }

DiskLruCache（磁盘缓存类）：

1 /*
2 * Copyright (C) 2011 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
17 package com.example.photoswall;
18
19 import java.io.BufferedInputStream;
20 import java.io.BufferedWriter;
21 import java.io.Closeable;
22 import java.io.EOFException;
23 import java.io.File;
24 import java.io.FileInputStream;
25 import java.io.FileNotFoundException;
26 import java.io.FileOutputStream;
27 import java.io.FileWriter;
28 import java.io.FilterOutputStream;
29 import java.io.IOException;
30 import java.io.InputStream;
31 import java.io.InputStreamReader;
32 import java.io.OutputStream;
33 import java.io.OutputStreamWriter;
34 import java.io.Reader;
35 import java.io.StringWriter;
36 import java.io.Writer;
37 import java.lang.reflect.Array;
38 import java.nio.charset.Charset;
39 import java.util.ArrayList;
40 import java.util.Arrays;
41 import java.util.Iterator;
42 import java.util.LinkedHashMap;
43 import java.util.Map;
44 import java.util.concurrent.Callable;
45 import java.util.concurrent.ExecutorService;
46 import java.util.concurrent.LinkedBlockingQueue;
47 import java.util.concurrent.ThreadPoolExecutor;
48 import java.util.concurrent.TimeUnit;
49
50 /**
51 ******************************************************************************
52 * Taken from the JB source code, can be found in:
53 * libcore/luni/src/main/java/libcore/io/DiskLruCache.java
54 * or direct link:
55 * https://android.googlesource.com/platform/libcore/+/android-4.1.1_r1/luni/src/main/java/libcore/io/DiskLruCache.java
56 ******************************************************************************
57 *
58 * A cache that uses a bounded amount of space on a filesystem. Each cache
59 * entry has a string key and a fixed number of values. Values are byte
60 * sequences, accessible as streams or files. Each value must be between {@code
61 * 0} and {@code Integer.MAX_VALUE} bytes in length.
62 *
63 * The cache stores its data in a directory on the filesystem. This
64 * directory must be exclusive to the cache; the cache may delete or overwrite
65 * files from its directory. It is an error for multiple processes to use the
66 * same cache directory at the same time.
67 *
68 * This cache limits the number of bytes that it will store on the
69 * filesystem. When the number of stored bytes exceeds the limit, the cache will
70 * remove entries in the background until the limit is satisfied. The limit is
71 * not strict: the cache may temporarily exceed it while waiting for files to be
72 * deleted. The limit does not include filesystem overhead or the cache
73 * journal so space-sensitive applications should set a conservative limit.
74 *
75 * Clients call {@link #edit} to create or update the values of an entry. An
76 * entry may have only one editor at one time; if a value is not available to be
77 * edited then {@link #edit} will return null.
78 * <ul>
79 * <li>When an entry is being created it is necessary to
80 * supply a full set of values; the empty value should be used as a
81 * placeholder if necessary.
82 * <li>When an entry is being edited, it is not necessary
83 * to supply data for every value; values default to their previous
84 * value.
85 * </ul>
86 * Every {@link #edit} call must be matched by a call to {@link Editor#commit}
87 * or {@link Editor#abort}. Committing is atomic: a read observes the full set
88 * of values as they were before or after the commit, but never a mix of values.
89 *
90 * Clients call {@link #get} to read a snapshot of an entry. The read will
91 * observe the value at the time that {@link #get} was called. Updates and
92 * removals after the call do not impact ongoing reads.
93 *
94 * This class is tolerant of some I/O errors. If files are missing from the
95 * filesystem, the corresponding entries will be dropped from the cache. If
96 * an error occurs while writing a cache value, the edit will fail silently.
97 * Callers should handle other problems by catching {@code IOException} and
98 * responding appropriately.
99 */
100 public final class DiskLruCache implements Closeable {
101 static final String JOURNAL_FILE = "journal";
102 static final String JOURNAL_FILE_TMP = "journal.tmp";
103 static final String MAGIC = "libcore.io.DiskLruCache";
104 static final String VERSION_1 = "1";
105 static final long ANY_SEQUENCE_NUMBER = -1;
106 private static final String CLEAN = "CLEAN";
107 private static final String DIRTY = "DIRTY";
108 private static final String REMOVE = "REMOVE";
109 private static final String READ = "READ";
110
111 private static final Charset UTF_8 = Charset.forName("UTF-8");
112 private static final int IO_BUFFER_SIZE = 8 * 1024;
113
114 /*
115 * This cache uses a journal file named "journal". A typical journal file
116 * looks like this:
117 * libcore.io.DiskLruCache
118 * 1
119 * 100
120 * 2
121 *
122 * CLEAN 3400330d1dfc7f3f7f4b8d4d803dfcf6 832 21054
123 * DIRTY 335c4c6028171cfddfbaae1a9c313c52
124 * CLEAN 335c4c6028171cfddfbaae1a9c313c52 3934 2342
125 * REMOVE 335c4c6028171cfddfbaae1a9c313c52
126 * DIRTY 1ab96a171faeeee38496d8b330771a7a
127 * CLEAN 1ab96a171faeeee38496d8b330771a7a 1600 234
128 * READ 335c4c6028171cfddfbaae1a9c313c52
129 * READ 3400330d1dfc7f3f7f4b8d4d803dfcf6
130 *
131 * The first five lines of the journal form its header. They are the
132 * constant string "libcore.io.DiskLruCache", the disk cache's version,
133 * the application's version, the value count, and a blank line.
134 *
135 * Each of the subsequent lines in the file is a record of the state of a
136 * cache entry. Each line contains space-separated values: a state, a key,
137 * and optional state-specific values.
138 * o DIRTY lines track that an entry is actively being created or updated.
139 * Every successful DIRTY action should be followed by a CLEAN or REMOVE
140 * action. DIRTY lines without a matching CLEAN or REMOVE indicate that
141 * temporary files may need to be deleted.
142 * o CLEAN lines track a cache entry that has been successfully published
143 * and may be read. A publish line is followed by the lengths of each of
144 * its values.
145 * o READ lines track accesses for LRU.
146 * o REMOVE lines track entries that have been deleted.
147 *
148 * The journal file is appended to as cache operations occur. The journal may
149 * occasionally be compacted by dropping redundant lines. A temporary file named
150 * "journal.tmp" will be used during compaction; that file should be deleted if
151 * it exists when the cache is opened.
152 */
153
154 private final File directory;
155 private final File journalFile;
156 private final File journalFileTmp;
157 private final int appVersion;
158 private final long maxSize;
159 private final int valueCount;
160 private long size = 0;
161 private Writer journalWriter;
162 private final LinkedHashMap<String, Entry> lruEntries
163 = new LinkedHashMap<String, Entry>(0, 0.75f, true);
164 private int redundantOpCount;
165
166 /**
167 * To differentiate between old and current snapshots, each entry is given
168 * a sequence number each time an edit is committed. A snapshot is stale if
169 * its sequence number is not equal to its entry's sequence number.
170 */
171 private long nextSequenceNumber = 0;
172
173 /* From java.util.Arrays */
174 @SuppressWarnings("unchecked")
175 private static <T> T[] copyOfRange(T[] original, int start, int end) {
176 final int originalLength = original.length; // For exception priority compatibility.
177 if (start > end) {
178 throw new IllegalArgumentException();
179 }
180 if (start < 0 || start > originalLength) {
181 throw new ArrayIndexOutOfBoundsException();
182 }
183 final int resultLength = end - start;
184 final int copyLength = Math.min(resultLength, originalLength - start);
185 final T[] result = (T[]) Array
186 .newInstance(original.getClass().getComponentType(), resultLength);
187 System.arraycopy(original, start, result, 0, copyLength);
188 return result;
189 }
190
191 /**
192 * Returns the remainder of 'reader' as a string, closing it when done.
193 */
194 public static String readFully(Reader reader) throws IOException {
195 try {
196 StringWriter writer = new StringWriter();
197 char[] buffer = new char[1024];
198 int count;
199 while ((count = reader.read(buffer)) != -1) {
200 writer.write(buffer, 0, count);
201 }
202 return writer.toString();
203 } finally {
204 reader.close();
205 }
206 }
207
208 /**
209 * Returns the ASCII characters up to but not including the next "\r\n", or
210 * "\n".
211 *
212 * @throws java.io.EOFException if the stream is exhausted before the next newline
213 * character.
214 */
215 public static String readAsciiLine(InputStream in) throws IOException {
216 // TODO: support UTF-8 here instead
217
218 StringBuilder result = new StringBuilder(80);
219 while (true) {
220 int c = in.read();
221 if (c == -1) {
222 throw new EOFException();
223 } else if (c == '\n') {
224 break;
225 }
226
227 result.append((char) c);
228 }
229 int length = result.length();
230 if (length > 0 && result.charAt(length - 1) == '\r') {
231 result.setLength(length - 1);
232 }
233 return result.toString();
234 }
235
236 /**
237 * Closes 'closeable', ignoring any checked exceptions. Does nothing if 'closeable' is null.
238 */
239 public static void closeQuietly(Closeable closeable) {
240 if (closeable != null) {
241 try {
242 closeable.close();
243 } catch (RuntimeException rethrown) {
244 throw rethrown;
245 } catch (Exception ignored) {
246 }
247 }
248 }
249
250 /**
251 * Recursively delete everything in {@code dir}.
252 */
253 // TODO: this should specify paths as Strings rather than as Files
254 public static void deleteContents(File dir) throws IOException {
255 File[] files = dir.listFiles();
256 if (files == null) {
257 throw new IllegalArgumentException("not a directory: " + dir);
258 }
259 for (File file : files) {
260 if (file.isDirectory()) {
261 deleteContents(file);
262 }
263 if (!file.delete()) {
264 throw new IOException("failed to delete file: " + file);
265 }
266 }
267 }
268
269 /** This cache uses a single background thread to evict entries. */
270 private final ExecutorService executorService = new ThreadPoolExecutor(0, 1,
271 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
272 private final Callable<Void> cleanupCallable = new Callable<Void>() {
273 @Override public Void call() throws Exception {
274 synchronized (DiskLruCache.this) {
275 if (journalWriter == null) {
276 return null; // closed
277 }
278 trimToSize();
279 if (journalRebuildRequired()) {
280 rebuildJournal();
281 redundantOpCount = 0;
282 }
283 }
284 return null;
285 }
286 };
287
288 private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize) {
289 this.directory = directory;
290 this.appVersion = appVersion;
291 this.journalFile = new File(directory, JOURNAL_FILE);
292 this.journalFileTmp = new File(directory, JOURNAL_FILE_TMP);
293 this.valueCount = valueCount;
294 this.maxSize = maxSize;
295 }
296
297 /**
298 * Opens the cache in {@code directory}, creating a cache if none exists
299 * there.
300 *
301 * @param directory a writable directory
302 * @param appVersion
303 * @param valueCount the number of values per cache entry. Must be positive.
304 * @param maxSize the maximum number of bytes this cache should use to store
305 * @throws java.io.IOException if reading or writing the cache directory fails
306 */
307 public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)
308 throws IOException {
309 if (maxSize <= 0) {
310 throw new IllegalArgumentException("maxSize <= 0");
311 }
312 if (valueCount <= 0) {
313 throw new IllegalArgumentException("valueCount <= 0");
314 }
315
316 // prefer to pick up where we left off
317 DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
318 if (cache.journalFile.exists()) {
319 try {
320 cache.readJournal();
321 cache.processJournal();
322 cache.journalWriter = new BufferedWriter(new FileWriter(cache.journalFile, true),
323 IO_BUFFER_SIZE);
324 return cache;
325 } catch (IOException journalIsCorrupt) {
326 // System.logW("DiskLruCache " + directory + " is corrupt: "
327 // + journalIsCorrupt.getMessage() + ", removing");
328 cache.delete();
329 }
330 }
331
332 // create a new empty cache
333 directory.mkdirs();
334 cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
335 cache.rebuildJournal();
336 return cache;
337 }
338
339 private void readJournal() throws IOException {
340 InputStream in = new BufferedInputStream(new FileInputStream(journalFile), IO_BUFFER_SIZE);
341 try {
342 String magic = readAsciiLine(in);
343 String version = readAsciiLine(in);
344 String appVersionString = readAsciiLine(in);
345 String valueCountString = readAsciiLine(in);
346 String blank = readAsciiLine(in);
347 if (!MAGIC.equals(magic)
348 || !VERSION_1.equals(version)
349 || !Integer.toString(appVersion).equals(appVersionString)
350 || !Integer.toString(valueCount).equals(valueCountString)
351 || !"".equals(blank)) {
352 throw new IOException("unexpected journal header: ["
353 + magic + ", " + version + ", " + valueCountString + ", " + blank + "]");
354 }
355
356 while (true) {
357 try {
358 readJournalLine(readAsciiLine(in));
359 } catch (EOFException endOfJournal) {
360 break;
361 }
362 }
363 } finally {
364 closeQuietly(in);
365 }
366 }
367
368 private void readJournalLine(String line) throws IOException {
369 String[] parts = line.split(" ");
370 if (parts.length < 2) {
371 throw new IOException("unexpected journal line: " + line);
372 }
373
374 String key = parts[1];
375 if (parts[0].equals(REMOVE) && parts.length == 2) {
376 lruEntries.remove(key);
377 return;
378 }
379
380 Entry entry = lruEntries.get(key);
381 if (entry == null) {
382 entry = new Entry(key);
383 lruEntries.put(key, entry);
384 }
385
386 if (parts[0].equals(CLEAN) && parts.length == 2 + valueCount) {
387 entry.readable = true;
388 entry.currentEditor = null;
389 entry.setLengths(copyOfRange(parts, 2, parts.length));
390 } else if (parts[0].equals(DIRTY) && parts.length == 2) {
391 entry.currentEditor = new Editor(entry);
392 } else if (parts[0].equals(READ) && parts.length == 2) {
393 // this work was already done by calling lruEntries.get()
394 } else {
395 throw new IOException("unexpected journal line: " + line);
396 }
397 }
398
399 /**
400 * Computes the initial size and collects garbage as a part of opening the
401 * cache. Dirty entries are assumed to be inconsistent and will be deleted.
402 */
403 private void processJournal() throws IOException {
404 deleteIfExists(journalFileTmp);
405 for (Iterator<Entry> i = lruEntries.values().iterator(); i.hasNext(); ) {
406 Entry entry = i.next();
407 if (entry.currentEditor == null) {
408 for (int t = 0; t < valueCount; t++) {
409 size += entry.lengths[t];
410 }
411 } else {
412 entry.currentEditor = null;
413 for (int t = 0; t < valueCount; t++) {
414 deleteIfExists(entry.getCleanFile(t));
415 deleteIfExists(entry.getDirtyFile(t));
416 }
417 i.remove();
418 }
419 }
420 }
421
422 /**
423 * Creates a new journal that omits redundant information. This replaces the
424 * current journal if it exists.
425 */
426 private synchronized void rebuildJournal() throws IOException {
427 if (journalWriter != null) {
428 journalWriter.close();
429 }
430
431 Writer writer = new BufferedWriter(new FileWriter(journalFileTmp), IO_BUFFER_SIZE);
432 writer.write(MAGIC);
433 writer.write("\n");
434 writer.write(VERSION_1);
435 writer.write("\n");
436 writer.write(Integer.toString(appVersion));
437 writer.write("\n");
438 writer.write(Integer.toString(valueCount));
439 writer.write("\n");
440 writer.write("\n");
441
442 for (Entry entry : lruEntries.values()) {
443 if (entry.currentEditor != null) {
444 writer.write(DIRTY + ' ' + entry.key + '\n');
445 } else {
446 writer.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
447 }
448 }
449
450 writer.close();
451 journalFileTmp.renameTo(journalFile);
452 journalWriter = new BufferedWriter(new FileWriter(journalFile, true), IO_BUFFER_SIZE);
453 }
454
455 private static void deleteIfExists(File file) throws IOException {
456 // try {
457 // Libcore.os.remove(file.getPath());
458 // } catch (ErrnoException errnoException) {
459 // if (errnoException.errno != OsConstants.ENOENT) {
460 // throw errnoException.rethrowAsIOException();
461 // }
462 // }
463 if (file.exists() && !file.delete()) {
464 throw new IOException();
465 }
466 }
467
468 /**
469 * Returns a snapshot of the entry named {@code key}, or null if it doesn't
470 * exist is not currently readable. If a value is returned, it is moved to
471 * the head of the LRU queue.
472 */
473 public synchronized Snapshot get(String key) throws IOException {
474 checkNotClosed();
475 validateKey(key);
476 Entry entry = lruEntries.get(key);
477 if (entry == null) {
478 return null;
479 }
480
481 if (!entry.readable) {
482 return null;
483 }
484
485 /*
486 * Open all streams eagerly to guarantee that we see a single published
487 * snapshot. If we opened streams lazily then the streams could come
488 * from different edits.
489 */
490 InputStream[] ins = new InputStream[valueCount];
491 try {
492 for (int i = 0; i < valueCount; i++) {
493 ins[i] = new FileInputStream(entry.getCleanFile(i));
494 }
495 } catch (FileNotFoundException e) {
496 // a file must have been deleted manually!
497 return null;
498 }
499
500 redundantOpCount++;
501 journalWriter.append(READ + ' ' + key + '\n');
502 if (journalRebuildRequired()) {
503 executorService.submit(cleanupCallable);
504 }
505
506 return new Snapshot(key, entry.sequenceNumber, ins);
507 }
508
509 /**
510 * Returns an editor for the entry named {@code key}, or null if another
511 * edit is in progress.
512 */
513 public Editor edit(String key) throws IOException {
514 return edit(key, ANY_SEQUENCE_NUMBER);
515 }
516
517 private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException {
518 checkNotClosed();
519 validateKey(key);
520 Entry entry = lruEntries.get(key);
521 if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER
522 && (entry == null || entry.sequenceNumber != expectedSequenceNumber)) {
523 return null; // snapshot is stale
524 }
525 if (entry == null) {
526 entry = new Entry(key);
527 lruEntries.put(key, entry);
528 } else if (entry.currentEditor != null) {
529 return null; // another edit is in progress
530 }
531
532 Editor editor = new Editor(entry);
533 entry.currentEditor = editor;
534
535 // flush the journal before creating files to prevent file leaks
536 journalWriter.write(DIRTY + ' ' + key + '\n');
537 journalWriter.flush();
538 return editor;
539 }
540
541 /**
542 * Returns the directory where this cache stores its data.
543 */
544 public File getDirectory() {
545 return directory;
546 }
547
548 /**
549 * Returns the maximum number of bytes that this cache should use to store
550 * its data.
551 */
552 public long maxSize() {
553 return maxSize;
554 }
555
556 /**
557 * Returns the number of bytes currently being used to store the values in
558 * this cache. This may be greater than the max size if a background
559 * deletion is pending.
560 */
561 public synchronized long size() {
562 return size;
563 }
564
565 private synchronized void completeEdit(Editor editor, boolean success) throws IOException {
566 Entry entry = editor.entry;
567 if (entry.currentEditor != editor) {
568 throw new IllegalStateException();
569 }
570
571 // if this edit is creating the entry for the first time, every index must have a value
572 if (success && !entry.readable) {
573 for (int i = 0; i < valueCount; i++) {
574 if (!entry.getDirtyFile(i).exists()) {
575 editor.abort();
576 throw new IllegalStateException("edit didn't create file " + i);
577 }
578 }
579 }
580
581 for (int i = 0; i < valueCount; i++) {
582 File dirty = entry.getDirtyFile(i);
583 if (success) {
584 if (dirty.exists()) {
585 File clean = entry.getCleanFile(i);
586 dirty.renameTo(clean);
587 long oldLength = entry.lengths[i];
588 long newLength = clean.length();
589 entry.lengths[i] = newLength;
590 size = size - oldLength + newLength;
591 }
592 } else {
593 deleteIfExists(dirty);
594 }
595 }
596
597 redundantOpCount++;
598 entry.currentEditor = null;
599 if (entry.readable | success) {
600 entry.readable = true;
601 journalWriter.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
602 if (success) {
603 entry.sequenceNumber = nextSequenceNumber++;
604 }
605 } else {
606 lruEntries.remove(entry.key);
607 journalWriter.write(REMOVE + ' ' + entry.key + '\n');
608 }
609
610 if (size > maxSize || journalRebuildRequired()) {
611 executorService.submit(cleanupCallable);
612 }
613 }
614
615 /**
616 * We only rebuild the journal when it will halve the size of the journal
617 * and eliminate at least 2000 ops.
618 */
619 private boolean journalRebuildRequired() {
620 final int REDUNDANT_OP_COMPACT_THRESHOLD = 2000;
621 return redundantOpCount >= REDUNDANT_OP_COMPACT_THRESHOLD
622 && redundantOpCount >= lruEntries.size();
623 }
624
625 /**
626 * Drops the entry for {@code key} if it exists and can be removed. Entries
627 * actively being edited cannot be removed.
628 *
629 * @return true if an entry was removed.
630 */
631 public synchronized boolean remove(String key) throws IOException {
632 checkNotClosed();
633 validateKey(key);
634 Entry entry = lruEntries.get(key);
635 if (entry == null || entry.currentEditor != null) {
636 return false;
637 }
638
639 for (int i = 0; i < valueCount; i++) {
640 File file = entry.getCleanFile(i);
641 if (!file.delete()) {
642 throw new IOException("failed to delete " + file);
643 }
644 size -= entry.lengths[i];
645 entry.lengths[i] = 0;
646 }
647
648 redundantOpCount++;
649 journalWriter.append(REMOVE + ' ' + key + '\n');
650 lruEntries.remove(key);
651
652 if (journalRebuildRequired()) {
653 executorService.submit(cleanupCallable);
654 }
655
656 return true;
657 }
658
659 /**
660 * Returns true if this cache has been closed.
661 */
662 public boolean isClosed() {
663 return journalWriter == null;
664 }
665
666 private void checkNotClosed() {
667 if (journalWriter == null) {
668 throw new IllegalStateException("cache is closed");
669 }
670 }
671
672 /**
673 * Force buffered operations to the filesystem.
674 */
675 public synchronized void flush() throws IOException {
676 checkNotClosed();
677 trimToSize();
678 journalWriter.flush();
679 }
680
681 /**
682 * Closes this cache. Stored values will remain on the filesystem.
683 */
684 public synchronized void close() throws IOException {
685 if (journalWriter == null) {
686 return; // already closed
687 }
688 for (Entry entry : new ArrayList<Entry>(lruEntries.values())) {
689 if (entry.currentEditor != null) {
690 entry.currentEditor.abort();
691 }
692 }
693 trimToSize();
694 journalWriter.close();
695 journalWriter = null;
696 }
697
698 private void trimToSize() throws IOException {
699 while (size > maxSize) {
700 // Map.Entry<String, Entry> toEvict = lruEntries.eldest();
701 final Map.Entry<String, Entry> toEvict = lruEntries.entrySet().iterator().next();
702 remove(toEvict.getKey());
703 }
704 }
705
706 /**
707 * Closes the cache and deletes all of its stored values. This will delete
708 * all files in the cache directory including files that weren't created by
709 * the cache.
710 */
711 public void delete() throws IOException {
712 close();
713 deleteContents(directory);
714 }
715
716 private void validateKey(String key) {
717 if (key.contains(" ") || key.contains("\n") || key.contains("\r")) {
718 throw new IllegalArgumentException(
719 "keys must not contain spaces or newlines: \"" + key + "\"");
720 }
721 }
722
723 private static String inputStreamToString(InputStream in) throws IOException {
724 return readFully(new InputStreamReader(in, UTF_8));
725 }
726
727 /**
728 * A snapshot of the values for an entry.
729 */
730 public final class Snapshot implements Closeable {
731 private final String key;
732 private final long sequenceNumber;
733 private final InputStream[] ins;
734
735 private Snapshot(String key, long sequenceNumber, InputStream[] ins) {
736 this.key = key;
737 this.sequenceNumber = sequenceNumber;
738 this.ins = ins;
739 }
740
741 /**
742 * Returns an editor for this snapshot's entry, or null if either the
743 * entry has changed since this snapshot was created or if another edit
744 * is in progress.
745 */
746 public Editor edit() throws IOException {
747 return DiskLruCache.this.edit(key, sequenceNumber);
748 }
749
750 /**
751 * Returns the unbuffered stream with the value for {@code index}.
752 */
753 public InputStream getInputStream(int index) {
754 return ins[index];
755 }
756
757 /**
758 * Returns the string value for {@code index}.
759 */
760 public String getString(int index) throws IOException {
761 return inputStreamToString(getInputStream(index));
762 }
763
764 @Override public void close() {
765 for (InputStream in : ins) {
766 closeQuietly(in);
767 }
768 }
769 }
770
771 /**
772 * Edits the values for an entry.
773 */
774 public final class Editor {
775 private final Entry entry;
776 private boolean hasErrors;
777
778 private Editor(Entry entry) {
779 this.entry = entry;
780 }
781
782 /**
783 * Returns an unbuffered input stream to read the last committed value,
784 * or null if no value has been committed.
785 */
786 public InputStream newInputStream(int index) throws IOException {
787 synchronized (DiskLruCache.this) {
788 if (entry.currentEditor != this) {
789 throw new IllegalStateException();
790 }
791 if (!entry.readable) {
792 return null;
793 }
794 return new FileInputStream(entry.getCleanFile(index));
795 }
796 }
797
798 /**
799 * Returns the last committed value as a string, or null if no value
800 * has been committed.
801 */
802 public String getString(int index) throws IOException {
803 InputStream in = newInputStream(index);
804 return in != null ? inputStreamToString(in) : null;
805 }
806
807 /**
808 * Returns a new unbuffered output stream to write the value at
809 * {@code index}. If the underlying output stream encounters errors
810 * when writing to the filesystem, this edit will be aborted when
811 * {@link #commit} is called. The returned output stream does not throw
812 * IOExceptions.
813 */
814 public OutputStream newOutputStream(int index) throws IOException {
815 synchronized (DiskLruCache.this) {
816 if (entry.currentEditor != this) {
817 throw new IllegalStateException();
818 }
819 return new FaultHidingOutputStream(new FileOutputStream(entry.getDirtyFile(index)));
820 }
821 }
822
823 /**
824 * Sets the value at {@code index} to {@code value}.
825 */
826 public void set(int index, String value) throws IOException {
827 Writer writer = null;
828 try {
829 writer = new OutputStreamWriter(newOutputStream(index), UTF_8);
830 writer.write(value);
831 } finally {
832 closeQuietly(writer);
833 }
834 }
835
836 /**
837 * Commits this edit so it is visible to readers. This releases the
838 * edit lock so another edit may be started on the same key.
839 */
840 public void commit() throws IOException {
841 if (hasErrors) {
842 completeEdit(this, false);
843 remove(entry.key); // the previous entry is stale
844 } else {
845 completeEdit(this, true);
846 }
847 }
848
849 /**
850 * Aborts this edit. This releases the edit lock so another edit may be
851 * started on the same key.
852 */
853 public void abort() throws IOException {
854 completeEdit(this, false);
855 }
856
857 private class FaultHidingOutputStream extends FilterOutputStream {
858 private FaultHidingOutputStream(OutputStream out) {
859 super(out);
860 }
861
862 @Override public void write(int oneByte) {
863 try {
864 out.write(oneByte);
865 } catch (IOException e) {
866 hasErrors = true;
867 }
868 }
869
870 @Override public void write(byte[] buffer, int offset, int length) {
871 try {
872 out.write(buffer, offset, length);
873 } catch (IOException e) {
874 hasErrors = true;
875 }
876 }
877
878 @Override public void close() {
879 try {
880 out.close();
881 } catch (IOException e) {
882 hasErrors = true;
883 }
884 }
885
886 @Override public void flush() {
887 try {
888 out.flush();
889 } catch (IOException e) {
890 hasErrors = true;
891 }
892 }
893 }
894 }
895
896 private final class Entry {
897 private final String key;
898
899 /** Lengths of this entry's files. */
900 private final long[] lengths;
901
902 /** True if this entry has ever been published */
903 private boolean readable;
904
905 /** The ongoing edit or null if this entry is not being edited. */
906 private Editor currentEditor;
907
908 /** The sequence number of the most recently committed edit to this entry. */
909 private long sequenceNumber;
910
911 private Entry(String key) {
912 this.key = key;
913 this.lengths = new long[valueCount];
914 }
915
916 public String getLengths() throws IOException {
917 StringBuilder result = new StringBuilder();
918 for (long size : lengths) {
919 result.append(' ').append(size);
920 }
921 return result.toString();
922 }
923
924 /**
925 * Set lengths using decimal numbers like "10123".
926 */
927 private void setLengths(String[] strings) throws IOException {
928 if (strings.length != valueCount) {
929 throw invalidLengths(strings);
930 }
931
932 try {
933 for (int i = 0; i < strings.length; i++) {
934 lengths[i] = Long.parseLong(strings[i]);
935 }
936 } catch (NumberFormatException e) {
937 throw invalidLengths(strings);
938 }
939 }
940
941 private IOException invalidLengths(String[] strings) throws IOException {
942 throw new IOException("unexpected journal line: " + Arrays.toString(strings));
943 }
944
945 public File getCleanFile(int i) {
946 return new File(directory, key + "." + i);
947 }
948
949 public File getDirtyFile(int i) {
950 return new File(directory, key + "." + i + ".tmp");
951 }
952 }
953 }

MD5Utils（MD5转换工具类）：

1 package com.example.photoswall;
2
3 import java.math.BigInteger;
4 import java.security.MessageDigest;
5 import java.security.NoSuchAlgorithmException;
6
7 public class MD5Utils {
8 /**
9 * 使用md5的算法进行加密
10 */
11 public static String md5(String plainText) {
12 byte[] secretBytes = null;
13 try {
14 secretBytes = MessageDigest.getInstance("md5").digest(
15 plainText.getBytes());
16 } catch (NoSuchAlgorithmException e) {
17 throw new RuntimeException("没有md5这个算法！");
18 }
19 String md5code = new BigInteger(1, secretBytes).toString(16);// 16进制数字
20 // 如果生成数字未满32位，需要前面补0
21 for (int i = 0; i < 32 - md5code.length(); i++) {
22 md5code = "0" + md5code;
23 }
24 return md5code;
25 }
26
27 }

上面三个类直接引入项目就行了，接下来说说核心实现代码了。

PhotoWallAdapter（GridView适配器类）：

说下思路：由于我们的图片源是单纯的字符串（网址），这里给GridView适配的Adpter采用ArrayAdapter，当然如果你想用BaseAdatper也是可以的，思路不变。

1、继承ArrayAdatper，在构造函数传入必要参数后，需要进行2个操作：1、对内存缓存类的初始化　　2、对磁盘缓存的初始化

2、然后在getView方法中来设置图片源，首先先设置成一张默认的图片，然后根据图片的URL去缓存中找是否有相关联的资源，如果没找到在磁盘缓存中找，如果还是没找到再去网络上下载，然后保存在磁盘缓存里，在以上的任一环节（磁盘，网络）里，只要我们找到了相对的图片资源，我们就把它添加到内存缓存中，以便下一次的引用。为了避免异步下载图片造成的图片错位现象，我们在每一个ImageView里设置了一个标识符Tag，Tag为图片的唯一标志：URL地址。

3、由于磁盘缓存属于I/O操作，网络属于下载操作都是属于耗时性的工作，这里我们开启了一个内部类Async异步类去完成，把所有的耗时操作都安排在doInBackground里执行（这里选择Async而不选择直接new Thread的原因是，Async运用了线程池的概念，会比单开子线程会更省资源，而且所有的任务会按照队列的顺序去执行）

由于这里的图片都是比较小的，在实际开发中，大家可以对利用BitmapFactory的Options类对图片进行压缩再展示。

1 package com.example.photoswall;
2
3 import java.io.BufferedInputStream;
4 import java.io.BufferedOutputStream;
5 import java.io.File;
6 import java.io.IOException;
7 import java.io.OutputStream;
8 import java.net.HttpURLConnection;
9 import java.net.URL;
10 import java.util.HashSet;
11 import java.util.Set;
12
13 import android.content.Context;
14 import android.content.pm.PackageInfo;
15 import android.content.pm.PackageManager.NameNotFoundException;
16 import android.graphics.Bitmap;
17 import android.graphics.BitmapFactory;
18 import android.os.AsyncTask;
19 import android.os.Environment;
20 import android.support.v4.util.LruCache;
21 import android.util.Log;
22 import android.view.LayoutInflater;
23 import android.view.View;
24 import android.view.ViewGroup;
25 import android.widget.ArrayAdapter;
26 import android.widget.GridView;
27 import android.widget.ImageView;
28
29 import com.example.photoswall.DiskLruCache.Snapshot;
30
31 public class PhotoWallAdapter extends ArrayAdapter<String> {
32
33 // 声明LruCache缓存对象
34 private LruCache<String, Bitmap> lruCache;
35 // 声明DiskLruCache硬盘缓存对象
36 private DiskLruCache diskLruCache;
37 // 任务队列
38 private Set<LoadImageAsync> tasks;
39 // 声明GridView对象
40 private GridView gridView;
41
42 public PhotoWallAdapter(Context context, int textViewResourceId, String[] objects, GridView gridView) {
43 super(context, textViewResourceId, objects);
44 this.gridView = gridView;
45 tasks = new HashSet<LoadImageAsync>();
46 /**
47 * 初始化内存缓存LruCache
48 */
49 // 获取应用程序最大可占内存值
50 int maxMemory = (int) Runtime.getRuntime().maxMemory();
51 // 设置最大内存的八分之一作为缓存大小
52 int lruMemory = maxMemory / 8;
53 lruCache = new LruCache<String, Bitmap>(lruMemory) {
54 @Override
55 protected int sizeOf(String key, Bitmap bitmap) {
56 // 返回Bitmap对象所占大小，单位：kb
57 return bitmap.getByteCount();
58 }
59
60 };
61 /**
62 * 初始化硬盘缓存DiskLruCahce
63 */
64 // 获取硬盘缓存路径,参数二为所在缓存路径的文件夹名称
65 File directory = getDiskCacheDir(getContext(), "bitmap");
66 if (!directory.exists()) {
67 // 若文件夹不存在，建立文件夹
68 directory.mkdirs();
69 }
70 int appVersion = getAppVersion(getContext());
71 try {
72 // 参数1：缓存文件路径，参数2：系统版本号，参数3：一个缓存路径对于几个文件，参数4：缓存空间大小：字节
73 diskLruCache = DiskLruCache.open(directory, appVersion, 1, 1024 * 1024 * 10);
74 } catch (IOException e) {
75 e.printStackTrace();
76 }
77
78 }
79
80 /**
81 * @param context
82 * @param uniqueName
83 * @return
84 * 当SD卡存在或者SD卡不可被移除的时候，就调用getExternalCacheDir()方法来获取缓存路径，否则就调用getCacheDir
85 * ()方法来获取缓存路径。前者获取到的就是 /sdcard/Android/data/<application
86 * package>/cache 这个路径而后者获取到的是 datadata/application package>/cache
87 * 这个路径。
88 */
89 public File getDiskCacheDir(Context context, String uniqueName) {
90 String cachePath;
91 if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) || !Environment.isExternalStorageRemovable()) {
92 cachePath = context.getExternalCacheDir().getPath();
93 } else {
94 cachePath = context.getCacheDir().getPath();
95 }
96 return new File(cachePath + File.separator + uniqueName);
97 }
98
99 /**
100 * @param context
101 * @return 获取系统版本号
102 */
103 public int getAppVersion(Context context) {
104 try {
105 PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
106 return info.versionCode;
107 } catch (NameNotFoundException e) {
108 e.printStackTrace();
109 }
110 return 1;
111 }
112
113 @Override
114 public View getView(int position, View convertView, ViewGroup parent) {
115 // 获取图片资源URL地址
116 String path = getItem(position);
117 View view = null;
118 if (convertView == null) {
119 view = LayoutInflater.from(getContext()).inflate(R.layout.gridview_item, null);
120 } else {
121 view = convertView;
122 }
123 // 获取控件实例
124 ImageView imageView = (ImageView) view.findViewById(R.id.iv_photo);
125 // 设置一个唯一标识符，避免异步加载图片时错位
126 imageView.setTag(path);
127 // 设置默认图片
128 imageView.setImageResource(R.drawable.ic_launcher);
129 // 根据图片URL到缓存中去找图片资源并设置
130 setImageFromLruCache(path, imageView);
131 return view;
132 }
133
134 /**
135 * 根据图片URL地址获取缓存中图片，若不存在去磁盘缓存中查找=》网络下载
136 *
137 * @param path
138 * @param imageView
139 */
140 private void setImageFromLruCache(String path, ImageView imageView) {
141 Bitmap bitmap = lruCache.get(path);
142 if (bitmap != null) {
143 // 缓存存在,取出设置图片
144 Log.i("PhotoWallAdapter", "在内存缓存中找到");
145 imageView.setImageBitmap(bitmap);
146 } else {
147 // 缓存不存在，先找硬盘缓存，还不存在，就去网络下载（开启异步任务）
148 LoadImageAsync loadImageAsync = new LoadImageAsync();
149 loadImageAsync.execute(path);
150 // 添加任务到任务队列
151 tasks.add(loadImageAsync);
152 }
153 }
154
155 /**
156 * 取消队列中准备下载和正在下载的任务
157 */
158 public void cancelTask() {
159 for (LoadImageAsync task : tasks) {
160 task.cancel(false);
161 }
162 }
163
164 /**
165 * 同步内存操作到journal文件
166 */
167 public void flushCache() {
168 if (diskLruCache != null) {
169 try {
170 diskLruCache.flush();
171 } catch (IOException e) {
172 e.printStackTrace();
173 }
174 }
175
176 }
177
178 class LoadImageAsync extends AsyncTask<String, Void, Bitmap> {
179 // 图片资源URL
180 String path = null;
181
182 @Override
183 protected Bitmap doInBackground(String... params) {
184 // 图片下载地址
185 this.path = params[0];
186 Snapshot snapshot = null;
187 OutputStream outputStream = null;
188 Bitmap bitmap = null;
189 String pathMd5 = MD5Utils.md5(path);
190 // 根据图片url（md5）查找图片资源是否存在于硬盘缓存
191 try {
192 snapshot = diskLruCache.get(pathMd5);
193 if (snapshot == null) {
194 // 在磁盘缓存中没有找到图片资源
195 // 获取一个DiskLruCache写入对象
196 DiskLruCache.Editor editor = diskLruCache.edit(pathMd5);
197 if (editor != null) {
198 outputStream = editor.newOutputStream(0);
199 // 开启异步网络任务获取图片，并存入磁盘缓存
200 if (downloadUrlToStream(path, outputStream)) {
201 // 下载成功
202 Log.i("PhotoWallAdapter", "下载文件成功");
203 editor.commit();
204 } else {
205 editor.abort();
206 }
207 }
208 }
209 // 图片写入磁盘缓存后，再一次的查找磁盘缓存
210 snapshot = diskLruCache.get(pathMd5);
211 if (snapshot != null) {
212 // 若查找到，获取图片，并把图片资源写入内存缓存
213 bitmap = BitmapFactory.decodeStream(snapshot.getInputStream(0));
214 Log.i("PhotoWallAdapter", "在磁盘缓存中找到");
215 }
216 if (bitmap != null) {
217 // 将Bitmap对象添加到内存缓存当中
218 lruCache.put(path, bitmap);
219 }
220 return bitmap;
221 } catch (IOException e) {
222 e.printStackTrace();
223 } finally {
224 if (outputStream != null) {
225 try {
226 outputStream.close();
227 } catch (IOException e) {
228 e.printStackTrace();
229 }
230 }
231 }
232 return null;
233 }
234
235 @Override
236 protected void onPostExecute(Bitmap bitmap) {
237 super.onPostExecute(bitmap);
238 // 根据Tag获取控件对象并设置图片
239 ImageView imageView = (ImageView) gridView.findViewWithTag(path);
240 if (imageView != null && bitmap != null) {
241 // 加载图片
242 imageView.setImageBitmap(bitmap);
243 }
244 tasks.remove(this);
245
246 }
247
248 /**
249 * 根据图片URL地址下载图片,成功返回true，失败false
250 *
251 * @param urlString
252 * @param outputStream
253 * @return
254 */
255 private boolean downloadUrlToStream(String urlString, OutputStream outputStream) {
256 HttpURLConnection urlConnection = null;
257 BufferedOutputStream out = null;
258 BufferedInputStream in = null;
259 try {
260 final URL url = new URL(urlString);
261 urlConnection = (HttpURLConnection) url.openConnection();
262 in = new BufferedInputStream(urlConnection.getInputStream(), 8 * 1024);
263 out = new BufferedOutputStream(outputStream, 8 * 1024);
264 int b;
265 while ((b = in.read()) != -1) {
266 out.write(b);
267 }
268 return true;
269 } catch (final IOException e) {
270 e.printStackTrace();
271 } finally {
272 if (urlConnection != null) {
273 urlConnection.disconnect();
274 }
275 try {
276 if (out != null) {
277 out.close();
278 }
279 if (in != null) {
280 in.close();
281 }
282 } catch (final IOException e) {
283 e.printStackTrace();
284 }
285 }
286 return false;
287 }
288
289 }
290
291 }

MainActivity类：

相比之下这个类就简单许多了，这里需要注意的两点:

1、在onPause方法里进行flush操作（更新磁盘缓存操作日志，磁盘缓存之所以能够被读取取决于日志文件）

2、在Activity销毁之前取消所有正在下载和准备下载的任务。

1 package com.example.photoswall;
2
3 import android.app.Activity;
4 import android.os.Bundle;
5 import android.widget.GridView;
6
7 public class MainActivity extends Activity {
8
9 private GridView gv_photo;
10 private PhotoWallAdapter adapter;
11
12 @Override
13 protected void onCreate(Bundle savedInstanceState) {
14 super.onCreate(savedInstanceState);
15 setContentView(R.layout.activity_main);
16 gv_photo = (GridView) findViewById(R.id.gv_photo);
17 adapter = new PhotoWallAdapter(MainActivity.this, 0, Images.imageThumbUrls, gv_photo);
18 gv_photo.setAdapter(adapter);
19
20 }
21
22 @Override
23 protected void onPause() {
24 super.onPause();
25 adapter.flushCache();
26 }
27
28 @Override
29 protected void onDestroy() {
30 super.onDestroy();
31 adapter.cancelTask();
32 }
33
34 }

剩下的一些细节，代码注释的很详细，还有不清楚的可以看看上文提到附带的2篇文章或者评论给我留言。

作者： Balla_兔子
出处： http://www.cnblogs.com/lichenwei/
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文链接。
正在看本人博客的这位童鞋，我看你气度不凡，谈吐间隐隐有王者之气，日后必有一番作为！旁边有“推荐”二字，你就顺手把它点了吧，相得准，我分文不收；相不准，你也好回来找我！

本文链接：安卓开发笔记——关于照片墙的实现（完美缓存策略LruCache+DiskLruCache），转载请注明。

Facebook是如何存储每天20亿张照片的——Cold Storage系统揭秘

Wed, 13 May 2015 10:35:30 CST

Facebook的庞大帝国需要存储的数据时刻都在不断爆炸。比方说，现在它每天要分享20亿张照片，而且需求还在不断增加，唯有靠不断建设扩充存储和数据中心才能满足。

此前我们曾多次介绍过Facebook的数据中心（见 Facebook新数据中心揭秘、再探Facebook数据中心），包括俄勒冈的Prineville、北卡罗来纳州的Forest和瑞典的吕勒奥以及爱荷华州的阿尔图纳拥等不仅如此，Facebook还大量采用自己自家的技术来搭建，并且把这种经验开放出来跟大家共享。这里面最先进的是最新的阿尔图纳数据中心，它采用了由廉价交换机组成的网状连接交换架构来提升性能，Facebook称之为下一代的数据中心—Data Center Fabric。

上述解决方案对于提升数据中心的网络性能、降低成本以及提高能效起到了非常关键的作用。但是对于存储需求的不断增加却没有办法，需要Facebook研究其他的应对措施。近日，Facebook 揭秘了自己的cold storage system存储系统是如何解决这个问题的。

顾名思义，cold storage（冷存储）存放的就是不常使用的数据，比如说几年前的历史数据。对于历史数据，传统的解决方案是采用带库、光盘等廉价介质来存储的，但是这种介质的缺点在于存取和访问速度太慢。Google不久前推出的云存储服务 Google Cloud Storage Nearline较好地解决了这个问题。

设计原则

不过Facebook团队决定用全新的角度去审视问题，他们从头开始，以端到端的方式重新设计了软硬件。

1）节能降耗

在这套以存储为核心的Cold Storage System中，存储资源是按需启动的，同时摒弃了冗余发电机或备用电池等以提高能效。由于cold storage采用的是低端商品化硬盘，硬件方面的约束要求进行命令批处理要非常小心，并且需要牺牲时延以换取效能。其对物理盘的存取是以平均故障间隔时间为基础控制硬盘的忙闲度（占空比）的。

2）智能管理

由于前面为了省电降低成本舍弃了备用电，这就要求软件任何时候都能应对哪怕是最小的电力中断，避免出现数据丢失的情况。

此外，数据还要具备持久性并保证完整性。为了保证持久性，系统设计时每一层面都要考虑持久性，消除单点故障，以尽可能少的步骤恢复整个系统，Cold Storage甚至连单独管理元数据的系统都是可有可无。也就是说，数据本身即可自我描述，不需要借助外部就能够辅助进行恢复。这么做的原因在于cold storage是其他系统数据丢失情况下的最后一道防线了。

3）面向未来

考虑到Facebook的数据设计时还需要考虑未来。很多系统在规模扩大或者利用率上升时往往就会性能下降或出问题，所以Facebook的这套系统一开始设计时就得考虑如何避免这一问题。

Facebook在Prineville的Cold Storage设施

基于上述考虑，目前Facebook已经在Prineville及Forest两个中心建设了两套cold storage系统，里面存放着数百PB（100万）的数据。不过如此的高容量其能耗仅为传统存储解决方案的1/4。而且跟一般系统不一样的是，这套系统的性能并不会随着规模扩大而下降，恰恰相反，系统越大性能反而越佳。最后一点值得关注的是，Facebook的这套存储系统采用了十分经济高效的冗余备份方式，可以以低于2的系数实现数据的备份冗余。从以上几点来看，作为一套半在线半离线存储系统，cold storage表现出来十分理想的特性。当然，要想发挥这套系统的效用，还需要Facebook开放计算体系如开放机架、网络、数据中心等其他组成部分的配合，一般人想学并不容易。

Cold Storage System的基础是 Open Vault Storage。这是一套专门针对Open Rack（开放计算的机架标准）打造的简单高效的存储解决方案，它采用了模块化的I/O拓扑，2U机框可容纳30块硬盘（每托盘15块硬盘，横放而不是竖放），几乎可以与任何服务器互操作。Cold Storage就是在这样一套高密度的 JBOD（Just a Bunch Of Disks ，磁盘簇）存储基础上修改而成的。

Cold Storage机架

硬盘按需启动，电耗降到1/4

降低耗电是系统一开始的设计目标之一。据介绍这套系统的耗电极低，降到了传统数据中心的1/6。其手段之一是以空间换降耗。数据中心占地面积非常大，满容的情况下每数据大厅可支撑1000PB的存储容量。随着以后单盘容量的提升，其存储规模还可以进一步扩大。

同时由于cold storage system存放的不是活跃的生产数据，而是历史数据，所以Facebook把冗余电力系统（不间断电源、发电机、备用电池等）也撤销了，从而进一步提升了能效。

架内布置，每2U放30块硬盘，电源插框放中间位置
为了尽可能降低能耗，Cold Storage允许服务器可以不带硬盘启动，然后由软件来控制忙闲度。不过这样就要求对Open Vault存储规范进行修改。其最大的改动是每次只允许每托盘有一块硬盘上电。为了避免软件bug错将所有硬盘上电导致数据中心保险烧坏，Facebook甚至还专门修改了硬盘驱动器的固件。

此外，由于不必每次都要给所有硬盘供电，每个存储节点散热风扇的数量也从6个降到了4个，供电机框数从3个降到了1个，供电单元数从7个降到了5个，Open Rack机架母线数特从3条降到了1条。这样的调优令机架的存储密度大大增加，每机架可容纳2PB的存储容量（4TB硬盘），与传统存储服务器相比，其耗电只有后者的1/4。

2U机箱，5*3块硬盘，绿色的是SAS扩展板

用经济的方式保证数据安全

传统上为了保证数据的安全，一般会采用多副本技术来避免硬件故障，但这么做需要拷贝几份数据，造成了资源的浪费，能不能在存放的数据不多于两份的情况下避免数据丢失呢？

尤其是Cold Storage采用的都是些廉价硬盘，而且又没有备用电池，故障中断等情况都是难免的。

怎么解决呢？Facebook采用了Reed Solomon Coding纠删码技术。纠删码是存储领域常用的数据冗余技术，其基本原理是将原始数据切分为n块，然后根据这几块生成m个校验块。利用算法，从从n个原始数据块和m 个校验块中任取n块就能解码出原始数据，也就是说进行这样的处理后，哪怕有m块数据同时丢失数据仍能恢复。通过将这些数据分到不同的故障域（如硬盘），Cold Storage就可以以较小的成本实现数据的保护。显然，校验块越多，可容忍的数据块出错数也就越多。当然，其代价是额外需要的硬盘也越多。

那多少才合适呢？这需要对硬盘的失败特征进行调查和建模才能确定数据分块数和校验块数。Facebook目前的配置是10:4（每10块硬盘配4块校验盘）。也就是说，用1.4GB的空间实现对1GB数据的备份，这种情况下可忍受4块硬盘同时坏掉。但是这种配比也会随着硬件特性以及对安全性的要求而变化的，因此Facebook开发了数据重新编码服务，这样就可以根据情况变化（存储媒体的可靠性）来重新灵活组织数据。

RS纠删码技术，把1GB数据切分为10块分别放在10块硬盘，另用4块硬盘放校验，可容忍4块硬盘同时坏掉
与以往模式相比，这种备份方式效率显然高得多，而且数据的持久性也大为增长。不过纠删码只能应付数据丢失，但是对于篡改却无能为力。为此，Facebook通过创建、维护及检查校验和来验证数据的完整性。而且这些校验和就挨着数据存放，一旦发现错误就马上从别处复制一份过来。

俗话说大脑越用越灵，不用则衰，存储也是这样。完全闲置或者不动的数据容易损坏，这就是所谓的“位衰减”。为此，Facebook在后台开启了一个“反熵”进程，专门用来定期扫描所有硬盘上的数据，从中检测数据畸变并报告。这个频率是每30天一次全扫描。一旦发现错误，另一个进程就会接管，然后读取足够多的数据去重建丢失的数据，并将其写入到新的硬盘上。由于整个过程将检测、失败分析与重构及保护分离开来，重构的耗时从小时级降到了分钟级。

Facebook还对数据存取进行了彻底改造。由于大多数现代文件系统在设计上的缺陷，这些文件系统基本上无法胜任短时间内进行大量频繁的加载与卸载操作。而且而且由于文件系统处在非常底层的位置，导致错误调试非常困难。Facebook的做法是跳过文件系统，将所有硬盘移植为“裸盘”。这样的好处是可以掌控整个数据流，从而进一步保证数据的持久性。
规模越大性能越好

传统系统往往规模越大性能就开始下降。Facebook希望避免这一点，甚至定下了越大越好的目标。其做法是每次增加容量时软件都要对现有数据进行再平衡—即将原有数据分配到新的硬件上，并释放之前用过的空间。这个过程并非实时进行，十分适合于在用系统的逐步移植，即既不影响系统的使用，又能逐步将数据迁移到新硬件上。如果把Cold Storage看作一块大硬盘的话，你可以把这种再平衡的做法视为智能硬盘整理程序。

未来计划

通过将冷数据（历史数据）与热数据（生产数据）分离、用冷存储系统处理冷数据的做法，Facebook得以实现降低能耗及节省其他资源节省的同时服务好数据请求。不过尽管目前Facebook的两套cold storage系统已经有数百PB的数据，但是这还只是整个数据量的1%，而且Facebook的数据每天还在不断增加。因此，社交巨头还需要继续扩大自己系统的规模，同时还将探索闪存、蓝光盘等各种存储媒介的利用，以及研究跨数据中心分布式存储文件数据的方法以改进持久性。

本文编译自： code.facebook.com

感谢 mengyidan1988 投递这篇资讯

资讯来源： 36氪

已有 0 人发表留言，猛击->> 这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

iOS 8 新改进(一)：相机与照片

Tue, 03 Jun 2014 04:36:42 CST

对于很喜欢用 iPhone 拍照，并且有大量照片保存的果迷来说，iOS 8 中的相机与照片改进可以说是非常值得一提的。

首先，iOS 8 的相机加入了延时摄影(Time-lapse)功能，这应该是继 Apple 加入“全景图拍摄”功能之后有一个炫酷且实用的功能。简单的说，延时摄影就是隔一段时间拍摄一张照片，最后合并成一个快速播放的视频。比如，你可以用演示摄影拍摄星斗转移、拍摄植物生长的过程、拍摄城市中熙熙攘攘的人群等等。

其次，iOS 8 中存储的照片和 iCloud 存储进行了完美整合。你用 iPhone 拍摄的任何一张照片，都会立刻自动同步到你的其他 Apple 设备中，比如 Mac、iPad，甚至网络相册中。

iCloud 照片库远不仅仅是帮你存储/同步那么简单，而且它还会自动将全尺寸的源文件存放于 iCloud 照片库中(甚至 RAW 格式的源文件)，而在你设备上显示的其实是适合你屏幕分辨率的轻量级照片，这样一来不仅会让本机照片库中的照片加载的更加流畅，而且也能节约你本机的空间。

当然，这样一来 iCloud 的存储空间就会费得很快，这应该是 Apple 故意这样的，要不怎么卖 iCloud 存储呢？用户存放在 iCloud 中的所有文件如果不超过5GB则免费，想要存放更多就需要付费了。Apple 宣布的两档套餐分别是：

20GB，0.99美元/月
100GB，3.99美元/月

第三，照片加入搜索功能，找照片更加容易。搜索可以根据拍摄的时间(包括大概时间)、地点、相册名等等作为关键词进行搜索。比如，你只记得之前在纽约拍摄了一张照片，有了搜索功能之后，就可以直接在搜索框中输入“纽约”，就可以筛选出所有你在纽约拍摄的照片，定位速度大大提高。

第四，智能编辑。这一点主要包含两个部分，一方面是智能调整，主要用于调整照片的亮度、颜色，并且还能进行对比度、曝光、阴影等多方面进行调整；另一方面是智能构图，比如当你拍摄了一张照片，但是由于持握手机的时候没有水平，导致找出的照片有点倾斜，拍摄之后程序可以自动帮你用旋转+裁切的方式修正。

第五，滤镜。目前在使用 iOS 7 的用户应该知道 Apple 已经有一些内置照片滤镜，但如果你对 Apple 的这些滤镜不满意的话，在 iOS 8 中甚至可以直接调用第三方 App 的滤镜。要使用这一功能，需要第三方 App 开发者允许他们的滤镜被 Apple 官方的”照片”应用访问。

法国费加罗报头版刊登的中国游客照片令法国人震撼

Sun, 01 Jun 2014 16:44:04 CST

【东方文化西方语微信公共号chinglish_zhaihua】法国《费加罗报》周六头版刊登一幅令法国人震惊的照片：一位中国游客被三个看上去像东欧吉普赛人的女性...... >>点击查看新浪博客原文

青春就应该这样绽放游戏测试：三国时期谁是你最好的兄弟！！你不得不信的星座秘密

二手手机恢复出4万张照片

Wed, 09 Jul 2014 14:03:36 CST

智能手机市场的繁荣，也造就了二手手机市场的兴旺，在美国很多人会通过eBay 和Craigslist 网站来出售他们使用过的手机。不过，似乎大家都没有做好数据清理工作。为了印证这个问题，杀毒公司Avast 做了一个测试，他们从eBay 上购买了20部二手Android 手机，使用基础的数据恢复软件进行处理，接着见证奇迹的时候到了，超过4万张照片从这些手机中恢复了出来，其中超过1500张是家人和孩子的照片，还有数千张是个人照片。除了照片之外，Avast 同时恢复了759封email 和短信，250个通讯地址。以及手机前机主信息等等。

讽刺的是，虽然有一部手机安装了安全软件，但恰恰是这部手机恢复出来的信息最多。通过手机信息再结合Google 搜索和Facebook 页面，Avast 的黑客很快就能找到机主各自信息，以及他曾去过的地方。甚至发现其中一名机主有一本《性骚扰指导》等。这样看上去，这些旧手机实在是太不安全了。

另一方面，一份调查显示，美国的智能手机用户只有14%安装了杀毒软件。8%的用户可以远程抹去手机里的信息。Avast 警告大家手机里的“恢复出场设定”并没有大家想象的那样完全清除。

当你在手机上删除一份文件的时候，理论上并没有真正的删除，操作系统会抹去指向这份文件的指针，知道该文件所在空间被覆盖后该文件才消失，在此之前，它都有可能恢复。Avast 的工作人员表示：“出售二手手机可以帮助人们赚得一些钱，但是却不能帮助你保护隐私。”而每天，在网络上都有约8万部二手智能手机在出售。

本次Avast 实验，具体恢复的数据，列表如下：
超过4万张图片
超过1500张关于家庭和孩子的照片
超过750张穿着内裤妹子的照片
超过250张自拍照片
超过1000个Google搜索历史记录
超过750封Email和短信
超过250个联系人信息
4个机主信息
1份完整的贷款信息

[ oioi via slashdot]

设计师上哪儿找照片素材？

Tue, 27 May 2014 10:52:13 CST

源自于知乎上的一个问题：作为一名设计师，你做设计是如何找素材的？我这边就分享一下关于照片素材的吧。以前说到过，前东家这样的跨国企业有自己的图库，按关键词搜之，质和量一般，但还能满足。来了狼厂之后似乎没有很好的 in-house 方式，如华盖之类的大厂牌图库价格又很贵，所以尝试过以个人途径去偏门的地方找图，比较常用的有以下：

在 Flickr 的搜索选项里勾上 CC 和可商用，然后按关键词查找，偶有让人惊艳的时候

Freeimages - 以前域名是 sxc.hu，上面的图质量都是「卡片机」级别的，但是好处是量大，搜啥都有一大堆，而且全部免费

最近用的比较多的是 Unsplash，每 10 天更新 10 张免费的 stock photos，照片总数有限，想要按主题找肯定是没戏，但如果就是提案的时候想要几张美图打底，那随便翻翻还是不错的

因为以前在 Envato Marketplaces 上卖过图标图标，有一些余额，所以本着不用白不用的原则在其下的 PhotoDune 买过一些图，普遍质量尚可，而且价格便宜

在需要把手机、Pad 界面放到生活中进行 mockup 的时候很喜欢 Placeit，经过一年多的快速发展，里面已经有相当多场景、机型可供选择，甚至有了动态的背景视频，网站速度慢点无解，不过还真是解决了我等 UI 设计师很多痛点。不得不提他家坑爹的会员功能，曾经帮客户做项目买过一个月会员以下载高清图，但是之后不想继续了还得手动发邮件取消 subscription

现实一点说，也有不保留节操仅供内部观赏就随便 Google 或者百度图片的时候，搜到泥土去泥土，搜到站哭去站哭

Tags - 照片 , 素材

如何通过几张穿着暴露艺术照片，找到当事人和拍摄地点？

Thu, 19 Dec 2013 23:49:23 CST

真心请大家不要再求种了！虽说发图不发种，菊花万人捅，但真的不能让隐秘信息从我这里泄露。。。。

首先需要声明的是，撸主并非技术宅或者技侦的爱好者。

只是机缘巧合，在撸主并未特别渴望获取相关图片等资源的情况下，撸主得到了两个艺术照片的压缩包（两个加起来月850MB）下载地址。

请相信我，撸主绝对是奔着其散发出的浓厚艺术气息，才决定下载的！

下载后解压缩，撸主丝毫没有被女主角曼妙的身材、坚挺的双峰、修长的美腿所打动，更没注意到木耳是黑色的等等细节！

为了网络和谐，为了文章不被和谐，过于不和谐的照片我就不放了。这几组照片的尺度绝对比从网黄老师放出来的要大得多。好吧，其实是已经不能更大了。

同时为了保护当事人，我把照片进行了处理。。

在撸主撸了一管，心满意足之后，突然有了思考人生的冲动：照片拍的这么好，不知道拍射者用的是何方神器？

于是撸主打开查看了照片属性：

我擦嘞！居然用的是我大iPhone5！

一看拍摄时间，2013年8月！

那时5s还没上市有木有！

能用起5的都是土豪有木有！

撸主向来喜欢和土豪做朋友，有木有！

此时一管刚完，一管又起。但撸主压制了自己撸管的冲动，决定继续发掘一点有用的信息。

各位土豪应该都知道，苹果手机有个功能，就是在拍照的时候给照片增加地理位置信息，这个功能可以让用户查看自己到底在哪拍过那些年不穿衣服的女孩。

好吧，请无视撸主手机里没有照片这一事实，�丝没有不穿衣服的女孩可拍，当然拍了也不会公然放在手机里。

于是乎，撸主继续把照片信息往下翻。

卧槽，居然看到了这样重要的信息！

亮度！白平衡！

这个信息太重要了！虽不明但觉厉啊！

请摄影专家来给大家科普一下！

于是撸主继续往下看！

我了个大去！！

果然让我找到了GPS位置信息有木有！

请原谅我再次隐藏了这个重要信息，为了保护当事人。

但，撸主不是GPS，并不能直接把这些数字转化成我能理解的地理位置。。

但撸主有一颗常人无法企及的聪明大脑：导入手机！

很可惜。。撸主的手机并不能显示导入照片的地理信息。。。照片都是我自己拍的。。

但！这可难不住撸主。。

各位想到了什么？

没错！神器GOOGLE EARTH！

打开神器，在添加地标里输入对应的经纬度，奇迹出现了！

这是中国中南某省某城市某区的某个普通的住宅小区。

在几组照片中，还有另外一个拍摄地点，

请无视最后几位的误差。。民用版本的GPS位置信息，有几十米的误差，是非常正常的。。。。

接下来，就需要用一点分析了：

用iphone5拍摄，说明两点，①是当事人不是像从网的黄老师那样专业拍私房照，②是双方对彼此有足够的信任。从很多更亲密的举动也可以佐证这一点。

而10组照片的拍摄时间，从8月初到10月末，历时大约三个月，但只有这两个拍摄地点。拍摄时间有白天有半夜，同时地点又是住宅小区，那我我有理由相信，所以很可能这两个地点就是当事人的居住地。

至此，假如我是个不法之人，准备拿着照片要挟一把，或者提出一些其他的诸如金钱等要求，完全可以去两个小区守株待兔！请注意，照片中女方的面容完全没有进行处理！

至此，我的故事讲完了。

我想说的是，随着手机功能越来越强大，大家经常喜欢把美好的事物记录下来，这本事件好事儿。

但是大家一定要注意自己的隐私。。像我这样的非技术人员，都可以按图索骥找到这么精确的信息，如果是真的技术员。。。。

经我测试，上传至人人网、q空间的照片，被下载后地理位置信息已经被擦除，目前看相对是安全的，但也许是因为我的能力不足。。

所以，提醒大家， 拍照有风险，上传需谨慎！

在这里告诉大家两个方法，除了加马赛克之外的处理照片内的敏感信息。

一，如果只有一两张照片，那么用windows自带的画图工具打开照片，然后另存为其他格式的照片，这个时候照片的exif信息都会被删除。

二，如果有很多照片要处理，那么可以安装这个免费的小工具（英文版的） Easy Exif Delete（点击打开百度盘）对照片的exif信息进行批量删除。

使用方法很简单，下载——解压缩——安装——运行软件

①进入软件后（如下图）先单击左侧“Select Images"，在弹出的对话框中选中需要处理的照片，如果照片含有GPS位置、拍照时间等信息，那么会看到 “Exif Found”

②在下面列表中，【 选中】需要处理的照片（单击选中一张，或者在选中一张后，用shift键+左键点击另一张，会批量选中），然后点击“Delete Exif”。处理完成后，会显示“Not Found”。如图。

当然，最好的不留位置信息的办法是，在拍照之前，请把GPS功能关闭！

最后提醒照片当事人：如果你们能看到我的帖子，赶紧搬家吧。。。。你们的信息不会从我这里外泄。。但是网络下载是开放的。。我能得到你们的照片。。别人也可以。。。

本文链接： http://www.yixieshi.com/youqu/15320.html

Google是如何让照片管理工具“Stories”学会讲故事的？

Tue, 22 Jul 2014 09:23:35 CST

“ Stories” 是Google+上一个很棒的照片管理工具，由Google 的社交网络工程师Joseph Smarr 负责。Stories 希望人们把所拍的照片都上传到网上，并自动将其生成为一个 由一系列照片讲述而成的故事。

也许Stories 所提供的功能听起来很简单——对人类而言，叙事能力是很自然的一件事。

。而机器不然。想让机器学会叙事的逻辑并不简单，哪怕你以用户在Google 上留下的所有信息为依据。“怎样让机器更懂人类的想法和情感？” 在这个问题上，Smarr 与他的团队花费了大量的时间。

Stories 的早期原型与最终成品差别巨大——Smarr 的团队进行了好一番探索。

最初的产品原型很有些个人年度报告的意思，里面包含了大量的数据，比如，在2012的5月的原型图里（下图）的数据就包括签到和徒步统计、与其他人的互动、音乐喜好，等等等等，数据精挑细选，细致而全面。背后的idea是，打造一款类似于Facebook News Feed 的产品：用算法对你的个人news 进行提炼。

但模型毕竟只是个模型。当真正开始琢磨能利用哪些Google 数据时，Smarr不幸的发现：“人们的历史（数据记录）充满噪音，且不完整。” 于是，他们继续打磨、调整idea，焦点最后总会回到照片上来。

他们开始针对用户进行调查，希望能找到新的思路。

针对用户最近拍摄的10张照片，他们发问：为什么要拍摄这些照片？拍给谁看？调查发现，一共有三种类型：拍照是为了给特定的人看；拍照是为了加强某个记忆，比如喜欢喝的啤酒，曾经路过想要下一次去地点等；第三种则是作为一种探险游历的证明。在调查中他们也发现探险游历类的照片是 其中意图最简单的。并且，前两种类型都相关性强的应用和服务，但第三种需求却没有被很好的满足。

Smarr 团队希望Stories可以解决这一需求。人们出去旅游时总是会拍摄大量的照片回来，但回到家后却不知道该如何处理这些照片。其中一小部分也许会被发布在Instagram上，但大部分就这样永远躺在了用户的电脑或手机里。而Stories就要成为人们一种探险有力的证明，用照片把人们的旅游故事尽量还原出来。

在此基础上，Smarr团队做了更多的测试。他们让更多的人参与到调查中来，让他们把照片打印并在桌子上排列开来。调查发现，大多数人会按照时间顺序从左到右排列照片，此外，很多用户都会挑出一张表示地理位置的照片，放在每次新地点游历的开头。

因此，Stories开始了对地理位置信息的提取。Stories 从每一个用户的”Google数据库“中截取的信息有：照片的定位信息、Google+和Google Maps的数据（通常可以知道用户去过哪里）、通过照片中的景物所推测出来的用户地理位置信息（特别适用于用相机而非手机所拍摄的照片）。Google 将运用它强大的计算能力对这些信息进行分析整合，勾画出一个故事，并用照片流的方式呈现出来。

最后，一起通过实际的例子来检验检验Stories有没有把故事讲好吧～

除非注明，本站文章均为原创或编译，转载请注明：文章来自 36氪

36氪官方iOS应用正式上线，支持『一键下载36氪报道的移动App』和『离线阅读』立即下载！

如何从SD卡中恢复你删除掉的照片

Tue, 25 Feb 2014 07:30:25 CST

我们即使再小心翼翼都有可能发生这样的事情：无论是你的数码相机落入了错误的人（比如小孩子）手里，还是有那么一瞬间你在面对着“全部删除”这样的信息，你或者是你所认识的人都有可能失手把你珍贵的照片从相机的存储卡中删掉。

放轻松一点~你仍然有很大的可能恢复这些文件，只要你没有再照更多的照片，或者往卡里写入任何其他的东西。

正如我去年在这个问题上发布的一篇文章所述，大多数相机上的简易删除命令仅仅是将存储卡上的空间标记为可用，而不是覆盖掉卡上对应的空间。只要你没有录入任何新的东西到卡上，之前删除的相片就应该可以比较容易的用一款文件恢复工具恢复。你甚至可能从已经重新格式化的存储卡恢复相片，只要你用的是标准格式化命令而不是低阶格式化命令（低格不仅仅删除卡上所有的数据，还重新生成卡上的目录和文件等结构，从而导致之前删除的文件无法恢复）。

在线搜索一下就会冒出来一大堆的文件恢复工具，其中许多都会提供一个免费版以供你预览一下可以恢复的文件，但是如果执行真正的恢复的话就需要你买这款软件啦！不过对于你大多数误删除的文件（也就是你手贱删掉，而不是磁盘故障的问题搞丢的那些），有大量的免费应用可以帮你恢复你的照片。现在我最钟情两款软件是Pandora Recovery 2.1.1和Recover File 2.1，两款都是基于Windows的应用。译者按：国内的用户可以试试R-Studio哦，软恢复神器；免费的DiskGenius也有不俗的表现，国产软件的翘楚！两款软件都有对用户较为友好的界面，但是我更偏爱Pandora Recovery一些，因为它的向导可以一步步地引导你，让恢复过程超级简单！Pandora Recovery能够恢复我所有删除掉的照片，以及我录在卡上的是视频文件。单用户版的Pandora Recovery可以免费下载，另外他们公司还提供了这一工具的“便携”版本——Pandora Mobile Recovery，不用安装就使用并且随1GB的U盘发售，7月末的价格是$19.95（通常是$39.95）。

Mac用户的选择就要少一些了，不过我试过其中两款：CG Security’s Photo 6.11.3和德国软件开发者Carsten Blüm的Exif Untrasher。PhotoRec用起来相对来说简单一些，尽管它是一款命令行应用程序，可能会让一些经验较少（xiaobai）的用户望而生畏。此外，最新版的PhotoRec（6.11.3）已经可以恢复视频文件和RAW格式的文件了。这两款软件的功能都如广告上说的那般好，尽管Exif Untrasher的界面明显的更加友好些。

你用过哪款照片恢复软件呢？请在评论栏中告诉我们吧！

如何从SD卡中恢复你删除掉的照片，首发于极客范 - GeekFan.net。

一秒钟变出一张真实场景下的产品屏幕截图照片

Tue, 30 Jul 2013 15:28:18 CST

比较拉风的应用通常在网站首页会放这样一张图，一双手拿着iPad或者iPhone，屏幕上显示的正是这款应用的使用场景，背后的物理实景则恰当的虚化掉，几个简单的单词，国际范儿！

范儿是好，但要拍出这么一张恰到好处的照片可不容易。有人在Hacker News上分享了一个取巧的办法，各位开发者伙伴纷纷点赞。

打开网站，挑选一张现成的模板图，备选的有iPhone、iPad、Mac和Android手机等多种款式。只需把你想放上去的应用截屏图片上传，原来模板图上空着的屏幕上就会显示出你的应用，分辨率对的话就是完美贴合的，看着跟实打实拍出的照片一样。

想起我小时候被拉到照相馆里站在布景图前拍照的场景了，去不了大海，就只能在画着大海的画布前拍照，好心酸...

目前这个网站上所有模板都是免费的，以后加入一些付费的高级版，应该也是有人愿意付费的。还有哪些类似的小点是值得琢磨的呢？

除非注明，本站文章均为原创或编译，转载请注明：文章来自 36氪

36氪官方iOS应用正式上线，支持『一键下载36氪报道的移动App』和『离线阅读』立即下载！

手机拍照技巧：怎么用手机拍出好看的照片？

Mon, 07 Oct 2013 20:02:15 CST

提问：怎么用手机拍出精彩的照片？

回答：（by Treee）

命题很大，我只能简单回答。先回答怎么拍精彩的照片，再回答怎么用手机拍。

怎么拍摄精彩的照片：

照片是视觉的表达，一切和视觉有关的东西，都是由于光的作用。学会用光。

照片是情绪、感受、思想的表达，这些需要由内及外，是照片的内涵。

在以上基础上，用光和思想来构图。

手机拍照的技巧：（这里只说和相机操作的不同）

iPhone原厂相机的曝光是由对焦点决定的，更换对焦点可以改变曝光值。

iPhone是固定F2.4的光圈，无法变光圈，光的明暗会决定你的快门时间。

大光比、逆光时可用HDR保留细节。拍摄大场景善用全景模式。

Snapseed是目前最好用的后期软件。滤镜最漂亮的是Instagram，推荐懒人用。

这样说起来很泛泛，我拿一张照片来说明一下：

清晨的光，会有初生的感觉，清新通透，色温偏凉。我把太阳构在树后，以免产生眩光或者过大的光比。同时阳光通过山和树发散过来的光有放射性，容易出现戏剧感。

前景的路牌我在那见了很多次，一直很爱。刚好那时是上学时间，有两个孩子从我身边走过，我兴奋地发现了这个巧合，于是我站好位置，等着他们往坡上走，走到阳光下，走到照片的视觉中心。在他们消失之前，我按了4张照片，这张是挑选过的。

因为光比很大，所以都用的HDR，保留细节。

由于光和我想要的内容比较统一，所以表达上没太大矛盾。

在拍之前，脑子里就已经有了这画面。

在后期里，我加了亮度、对比、拉高了暗部细节，让照片更通透。同时加了暗角，让视觉点更中心化。

废话一下：一张好的照片，起决定作用的不是器材，是你的眼睛和脑子，以及长期反复地训练。现在很多人都很关心“后期”，这样其实是很投机取巧的。好照片基本都是在前期决定的。

前天周晓欧说，饭要一口一口的吃，人要慢慢长大。不喜欢一夜成名的人，想干这行就要把音乐底子打好，这是最关键的。

拍照，也一样。（来源）

小提示：如果文章有分页可能会被截断，请点此阅读全文。

佳人专注精品阅读5年，多谢佳友们的支持，请记得在QQ邮件底部评分处打5颗星噢~~

把佳人藏进QQ邮箱 | 人气热文 | 投稿 | 微博 | 小组 | 佳人首页 | 佳人在微信里等你

佳人推荐：

最梦魇故事：我不坐台好多年，刹那芳华飞灰烟灭

最霸气故事：开始行动，收拾贱三，全程直播

一个超准的心理测试：你最大的弱点是什么？

最心碎故事：和我在一起十年的姑娘，要给别人当妈了

佳人猜您也喜欢：
7个不可不学的人像摄影技巧	漫画：那些年，我们没有智能手机的日子	真假照片	自己动手做手机（视频）	手机丢了怎么办？
无觅

android 比较靠谱的选择图片以及拍照，保存图片

Thu, 27 Sep 2012 22:51:11 CST

在开发项目中用到这个功能，之前就按照学过的拍照和选择照片的功能，所以也没在意就写了上去，可是最后发现在有些机子里面获取到的数据时空的，所以会导致程序崩溃的情况出现，网上找了很多例子大多都是一样的，还是有问题，后来就查看跟踪了拍照后返回的数据写了下面的代码相对大多数机子是可行的，经测试还是比较靠谱的，包括拍照后图片翻转了90度问题都没问题。直接看代码：

第一：拍照选择界面：

import android.app.Activity;
import android.content.ActivityNotFoundException;
import android.content.Intent;
import android.os.Bundle;
import android.provider.MediaStore;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.Toast;

public class SelectPicPopupWindow extends Activity implements OnClickListener {

	private Button btn_take_photo, btn_pick_photo, btn_cancel;
	private LinearLayout layout;
	private Intent intent;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.alert_dialog);
		intent = getIntent();
		btn_take_photo = (Button) this.findViewById(R.id.btn_take_photo);
		btn_pick_photo = (Button) this.findViewById(R.id.btn_pick_photo);
		btn_cancel = (Button) this.findViewById(R.id.btn_cancel);

		layout = (LinearLayout) findViewById(R.id.pop_layout);

		// 添加选择窗口范围监听可以优先获取触点，即不再执行onTouchEvent()函数，点击其他地方时执行onTouchEvent()函数销毁Activity
		layout.setOnClickListener(new OnClickListener() {

			public void onClick(View v) {
				// TODO Auto-generated method stub
				Toast.makeText(getApplicationContext(), "提示：点击窗口外部关闭窗口！",
						Toast.LENGTH_SHORT).show();
			}
		});
		// 添加按钮监听
		btn_cancel.setOnClickListener(this);
		btn_pick_photo.setOnClickListener(this);
		btn_take_photo.setOnClickListener(this);
	}

	// 实现onTouchEvent触屏函数但点击屏幕时销毁本Activity
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		finish();
		return true;
	}

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		if (resultCode != RESULT_OK) {
			return;
		}
		//选择完或者拍完照后会在这里处理，然后我们继续使用setResult返回Intent以便可以传递数据和调用
		if (data.getExtras() != null)
			intent.putExtras(data.getExtras());
		if (data.getData()!= null)
			intent.setData(data.getData());
		setResult(1, intent);
		finish();

	}

	public void onClick(View v) {
		switch (v.getId()) {
		case R.id.btn_take_photo:
			try {
				//拍照我们用Action为MediaStore.ACTION_IMAGE_CAPTURE，
				//有些人使用其他的Action但我发现在有些机子中会出问题，所以优先选择这个
				Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
				intent.setAction(MediaStore.ACTION_IMAGE_CAPTURE);
				startActivityForResult(intent, 1);
			} catch (Exception e) {
				e.printStackTrace();
			}
			break;
		case R.id.btn_pick_photo:
			try {
				//选择照片的时候也一样，我们用Action为Intent.ACTION_GET_CONTENT，
				//有些人使用其他的Action但我发现在有些机子中会出问题，所以优先选择这个
				Intent intent = new Intent();
				intent.setType("image/*");
				intent.setAction(Intent.ACTION_GET_CONTENT);
				startActivityForResult(intent, 2);
			} catch (ActivityNotFoundException e) {

			}
			break;
		case R.id.btn_cancel:
			finish();
			break;
		default:
			break;
		}

	}

}

第二：显示照片界面：

import android.app.Activity;
import android.content.Intent;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ImageView;

public class MainActivity extends Activity {
	private ImageView photo;

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		photo = (ImageView) this.findViewById(R.id.text);
		// 把文字控件添加监听，点击弹出自定义窗口
		photo.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				//使用startActivityForResult启动SelectPicPopupWindow当返回到此Activity的时候就会调用onActivityResult函数
				startActivityForResult(new Intent(MainActivity.this,
						SelectPicPopupWindow.class), 1);
			}
		});
	}

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {

		switch (resultCode) {
		case 1:
			if (data != null) {
				//取得返回的Uri,基本上选择照片的时候返回的是以Uri形式，但是在拍照中有得机子呢Uri是空的，所以要特别注意
				Uri mImageCaptureUri = data.getData();
				//返回的Uri不为空时，那么图片信息数据都会在Uri中获得。如果为空，那么我们就进行下面的方式获取
				if (mImageCaptureUri != null) {
					Bitmap image;
					try {
						//这个方法是根据Uri获取Bitmap图片的静态方法
						image = MediaStore.Images.Media.getBitmap(this.getContentResolver(), mImageCaptureUri);
						if (image != null) {
							photo.setImageBitmap(image);
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				} else {
					Bundle extras = data.getExtras();
					if (extras != null) {
						//这里是有些拍照后的图片是直接存放到Bundle中的所以我们可以从这里面获取Bitmap图片
						Bitmap image = extras.getParcelable("data");
						if (image != null) {
							photo.setImageBitmap(image);
						}
					}
				}

			}
			break;
		default:
			break;

		}
	}

}

第三：如果需要保存图片到SD卡或者上传图片可以用下面代码：

public static String savePicToSdcard(Bitmap bitmap, String path,
			String fileName) {
		String filePath = "";
		if (bitmap == null) {
			return filePath;
		} else {

			filePath=path+ fileName;
			File destFile = new File(filePath);
			OutputStream os = null;
			try {
				os = new FileOutputStream(destFile);
				bitmap.compress(CompressFormat.JPEG, 100, os);
				os.flush();
				os.close();
			} catch (IOException e) {
				filePath = "";
			}
		}
		return filePath;
	}

上传图片的话我们可以获取bitmap的流然后上传，如上面方式获取，如要上传，上传代码自己实现，这个比较简单。

运行效果图：

已有 0 人发表留言，猛击->> 这里<<-参与讨论

ITeye推荐

—软件人才免语言低担保赴美带薪读研！—

为什么数码相机可以拍出彩色照片？

Thu, 06 Dec 2012 20:31:14 CST

上个月（11 月 13 日），83 岁的柯达公司退休工程师布赖斯·拜尔（Bryce Bayer）去世。

一家国内杂志邀请我写纪念文章，回顾他对数码摄影的巨大贡献。

我看了一些材料，觉得这个题材很有意思，涉及数码相机的成像原理，使我对数字图像技术有了新的认识。但是，由于体例限制，杂志不允许我插入彩图。

下面，我把我的那篇文章配上图片，解释彩色数码照片是怎么拍出来的。

为了更好地理解原理，让我们从照片的起源讲起。1825 年，法国人涅普斯（Joseph Nicéphore Nièpce），拍出历史上第一张照片。

他采用的感光剂是氯化银（silver chloride）。当光线照射氯化银，后者会分解成纯银和氯气，纯银在空气中很快氧化变成黑色。因此，底片颜色越深代表光线越强，颜色越浅代表光线越弱。黑白照片就是这样拍出来。

19 世纪中期，人们发现，人眼的圆锥细胞对三种颜色----红、绿、蓝----特别敏感。伟大的英国物理学家麦克斯韦因此假设，红绿蓝作为基色，可以拍出彩色照片。

1861 年，在麦克斯韦的指导下，人类的第一张彩色照片诞生了。

采用的方法是在镜头前，分别用红丝带、绿丝带、蓝丝带过滤光线，曝光形成三张底片，然后用三部放映机向同一处投影这三张底片，每部放映机的镜头前都拧上对应颜色的镜头，它们的合成效果就是一张彩照。

真正意义上的彩色胶卷，1933 年诞生于柯达公司，底片之上依次有三个感光层，分别对红、绿、蓝三种颜色进行曝光，最后叠加形成一张彩色底片。

二战后，计算机诞生，科学家发现图像可以用数字形式表示。如果将光信号转变成电信号，就可以直接拍出数码照片。这意味着，照相机不再需要胶卷，而是需要一个图像传感器（image sensor）。

图像传感器将光线转化成电流，光线越亮，电流的数值就越大；光线越暗，电流的数值就越小。所以，如果用 0 到 255 的范围，表示光线的亮度，最亮的光线是白光，数值是十六进制的 FF，最暗的光线是黑光（没有光），数值是十六进制的 00。

图像传感器的表面，分成若干个捕捉点，每个点都会产生一个数值，表示该点感受到的光线亮度，这就叫做"像素"。像素越多，图像细节就越丰富。如果一台照机的像素是 1600x1200，就说明图像传感器横向有 1600 个捕捉点，纵向有 1200 个，合计 192 万个。

但是，图像传感器有一个很严重的缺陷：它只能感受光的强弱，无法感受光的波长。由于光的颜色由波长决定，所以图像传播器无法记录颜色，也就是说，它只能拍黑白照片，这肯定是不能接受的。

10.

一种解决方案是照相机内置三个图像传感器，分别记录红、绿、蓝三种颜色，然后再将这三个值合并。这种方法能产生最准确的颜色信息，但是成本太高，无法投入实用。

11.

1974 年，柯达公司的工程师布赖斯·拜尔提出了一个全新方案，只用一块图像传感器，就解决了颜色的识别。他的做法是在图像传感器前面，设置一个滤光层（Color filter array），上面布满了滤光点，与下层的像素一一对应。也就是说，如果传感器是 1600x1200 像素，那么它的上层就有 1600x1200 个滤光点。

12.

每个滤光点只能通过红、绿、蓝之中的一种颜色，这意味着在它下层的像素点只可能有四种颜色：红、绿、蓝、黑（表示没有任何光通过）。

13.

不同颜色的滤光点的排列是有规律的：每个绿点的四周，分布着 2 个红点、2 个蓝点、4 个绿点。这意味着，整体上，绿点的数量是其他两种颜色点的两倍。这是因为研究显示人眼对绿色最敏感，所以滤光层的绿点最多。

14.

接下来的问题就是，如果一个像素只可能有四种颜色，那么怎么能拍出彩色照片呢？这就是布赖斯·拜尔聪明的地方，前面说了，每个滤光点周围有规律地分布其他颜色的滤光点，那么就有可能结合它们的值，判断出光线本来的颜色。以黄光为例，它由红光和绿光混合而成，那么通过滤光层以后，红点和绿点下面的像素都会有值，但是蓝点下面的像素没有值，因此看一个像素周围的颜色分布----有红色和绿色，但是没有蓝色----就可以推测出来这个像素点的本来颜色应该是黄色。

15.

这种计算颜色的方法，就叫做 "去马赛克"（demosaicing）。上图的下半部分是图像传感器生成的"马赛克"图像，所有的像素只有红、绿、蓝、黑四种颜色；上半部分是"去马赛克"后的效果，这是用算法处理的结果。

16.

虽然，每个像素的颜色都是算出来的，并不是真正的值，但是由于计算的结果相当准确，因此这种做法得到广泛应用。目前，绝大部分的数码相机都采用它，来生成彩色数码照片。高级的数码相机，还提供未经算法处理的原始马赛克图像，这就是 raw 格式（raw image format）。

为了纪念发明者布赖斯·拜尔，它被称作"拜尔模式"或 "拜尔滤光法" （Bayer filter）。

本文链接

android获取本地图片或拍照图片

Wed, 20 Feb 2013 21:31:21 CST

直接上代码，代码中注释很清楚，本人觉得这个东西google本来自己就应该集成好，直接一个方法调用最好，因为这个用的比较多，一般的android手机中交流的软件基本上都需要这个东西。

package com.example.photodemo;

import android.app.Activity;
import android.content.ContentResolver;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Bundle;
import android.os.Environment;
import android.provider.MediaStore;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.Toast;

public class MainActivity extends Activity {

	private ImageView image;// 要显示选择的图片
	private Bitmap photo;// 选择好的图片的bitmap形式
	
	private Button button1;// 图片
	private Button button2;// 拍照
	private static final int PIC = 1;// 图片
	private static final int PHO = 2;// 照相

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		super.setContentView(R.layout.activity_main);
		button1 = (Button) findViewById(R.id.button1);
		button2 = (Button) findViewById(R.id.button2);
		image = (ImageView) findViewById(R.id.imageView1);
		button1.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				Intent intent = new Intent();
				intent.setType("image/*");
				intent.setAction(Intent.ACTION_GET_CONTENT);
				startActivityForResult(intent, PIC);
			}
		});
		// 拍照上传
		button2.setOnClickListener(new OnClickListener() {
			@Override
			public void onClick(View v) {
				String state = Environment.getExternalStorageState();
				if (state.equals(Environment.MEDIA_MOUNTED)) {// 如果存储卡可用
					Intent intent = new Intent(
							"android.media.action.IMAGE_CAPTURE");
					startActivityForResult(intent, PHO);
				} else {
					Toast.makeText(getApplicationContext(), "存储卡不可用",
							Toast.LENGTH_LONG).show();
				}
			}
		});
	}

	/**
	 * 取得回传的数据
	 */
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		if (data != null && requestCode == PHO) { // 拍照上传时
			Bundle extras = data.getExtras();
			if (extras != null) {
				photo = (Bitmap) extras.get("data");
				image.setImageBitmap(photo);
			} else {
				Toast.makeText(MainActivity.this, "未找到图片", Toast.LENGTH_LONG)
						.show();
			}
		}
		if (resultCode == Activity.RESULT_OK) {
			Uri uri = data.getData();// 当选择的图片不为空的话，在获取到图片的途径
			try {
				String[] pojo = { MediaStore.Images.Media.DATA };
				Cursor cursor = managedQuery(uri, pojo, null, null, null);
				if (cursor != null) {
					ContentResolver cr = this.getContentResolver();
					int colunm_index = cursor
							.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
					cursor.moveToFirst();
					String path = cursor.getString(colunm_index);
					/***
					 * 这里加这样一个判断主要是为了第三方的软件选择，比如：使用第三方的文件管理器的话，你选择的文件就不一定是图片了，
					 * 这样的话，我们判断文件的后缀名 如果是图片格式的话，那么才可以
					 */
					if (path.endsWith("jpg") || path.endsWith("png")) {
						photo = BitmapFactory.decodeStream(cr
								.openInputStream(uri));
						image.setImageBitmap(photo);
					} else {
					}
				} else {
				}
			} catch (Exception e) {
			}
		}
	}
}

布局也顺便写一下吧

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity" >

    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="选择相片" />

    <Button
        android:id="@+id/button2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="拍照相片" />

    <EditText
        android:id="@+id/editText1"
        android:layout_width="match_parent"
        android:layout_height="150dp"
        android:ems="10"
        android:inputType="textMultiLine" >

        <requestFocus />
    </EditText>

    <ImageView
        android:id="@+id/imageView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/ic_launcher" />

</LinearLayout>

作者：Wang6279026 发表于2013-2-20 21:31:21 原文链接

阅读：71 评论：0 查看评论

社交网站易引发嫉妒心理度假照片为最大诱因

Wed, 13 Feb 2013 11:14:01 CST

德国最新调查显示，Facebook上好友发布的度假、爱情生活、工作成就等信息会引发嫉妒心理，并由此让人感到痛苦和寂寞。德国两所大学合作开展的这项调查发现，Facebook引发嫉妒心理的情况十分普遍，并成为前所未有的社会比较平台。全球最大的社交网站Facebook用户数量已经超过10亿。

研究人员发现，三分之一的人们在浏览Facebook后感觉心情更糟，对生活更加不满；而那些只是浏览却没有上传任何信息的人受到的负面影响最深。

柏林洪堡大学信息系统研究所研究员汉娜告诉记者：“我们发现很多人浏览Facebook后会产生嫉妒心理，这让他们感到孤独、沮丧或者气愤，人数之多让我们感到很惊讶。”

汉娜说：“根据我们的观察，有些受到负面影响的人会停止使用Facebook，或者至少减少使用时间。”汉娜还预测说，Facebook在某些市场可能会达到饱和。

来自德国柏林洪堡大学以及达姆施塔特工业大学的研究人员发现，假期照片是引起愤恨的最大诱因，超过半数的嫉妒心理来源于Facebook上的假期掠影。

社交互动是引起嫉妒心理的第二大常见原因，用户会比较自己和好友收到生日祝福的数量，以及照片和帖子获得多少“赞”或评论。

研究人员在周二发布的名为《Facebook引发嫉妒心理：用户生活满意度的潜在威胁》报告中指出：“被动浏览会让人产生反感，用户主要是在嫉妒别人的幸福生活、度假方式和社交活动。”

“研究表明，社交网络引发的嫉妒心理的蔓延和无所不在会降低用户的生活满意度。”

30多的人大多会嫉妒他人的家庭幸福，而女性大多会嫉妒别人的外貌。

调查发现，这种嫉妒心理会让某些用户在Facebook上夸大自己的成就,以更好地表现自己。

调查显示，男性大多会在Facebook网站上自我宣传，从而让人们知道自己的成就，而女性则注重表现自己的娇好的样貌和丰富的社交生活。

研究人员根据两项调查得出了上述结论，共有600人参与调查。研究结果将在于今年二月在德国举行的信息系统会议上公布。

第一项研究专注于由Facebook引发的嫉妒心理事件的规模、范围和性质；第二项研究则注重于这些嫉妒心理对Facebook使用以及用户的生活满意度带来的负面影响。

研究人员表示，虽然两项调查中的参与者都是德国人，但其结果仍具有国际意义，因为嫉妒心理是人类普遍存在的情绪，而且它可能会影响Facebook的使用。

研究人员总结道：“从供应商的角度来看，我们的研究结果表明，用户时常感觉Facebook氛围压抑，长期来看，这会危及这个社交平台的持续发展。”

你可能也喜欢：
日本第一大社交网站Mixi正式发布中文版	全球社交网站网络地图 Facebook地盘最大	未来社交网站的5大趋势	社交网站2.0：专注用户兴趣而非真实社交圈	社交网站成功之道：像人类学家那样思考
无觅

Feed enhanced by Better Feed from Ozh

文章照片等数字资源版权自我保护方法

Sat, 08 Mar 2014 22:28:44 CST

　　在互联网的世界，文档、照片、软件等等数字资源的版权都极其容易受到盗取，最终导致自己辛勤劳动的成果不能得到保护。由于在版权保护机构登记是要费用的，一般除了重大的一些成果，我们很少会自己承担这些费用。举一个很简单的例子，如果你写了一篇文章，然后你投了几个报社，最后某报社直接刊登了你的文章而拒绝给稿费，更可恨的是还口口声声说不是你写的，由于你未做任何措施，百口莫辩，只能哑巴吞黄连，就是打官司也没有一点胜算。

　　我们提供一种假设，假如你在投稿前能通过某种手段证明我手上现在就有这个稿件了，接着再进行投稿，而报社再过了一段时间出版了你的文章且没付你相应的报酬，但这时我不怕没证据了，因为我投稿前已经通过某种手段证明我有这个稿件了，我在报社出版的时间之前就已经有这个稿件了，足以证明自己比报社更早拥有稿件，自然有能力保护自己的合法权益。如下图，时间轴一直往前，四个时间点分别发生了四个事件，权威机构证明的时间点①比报社出版时间点③早，很明显可以说明谁先拥有稿件。前面提到的某种手段就是本文想要提出的一种自我保护方法。

　　从上面可以看出，任何事件都对应着时间点，要说明某事件发生的时间，我们必须为其贴上时间的标签并且妥善保存记录介质。我们常见的时间标签有哪些呢？例如报纸，我们经常会在警匪片中看到匪徒用报纸跟人质一起拍照，以此来证明人质还活着，为什么能如此证明？因为报纸上有日期时间，且报纸上报告的新闻不可伪造，那么至少可以证明到报纸上的时间内人质没被撕票。即报纸存在以下两种特性使之能成为时间证明：

　　报纸具有时间性，报纸每天都印刷发布，每天的日期都不一样；

　　报纸具有不可为造型，每天的新闻都不一样，你永远不可能预测明天会发生什么，所没人能提前伪造报纸。

　　这样我们可以看成是人质活着的事件被报纸上的时间贴上了时间标签，并且这是一个可靠的时间戳。如下图，绑匪给小女生跟报纸拍下的照片证明了时间轴阴影部分的任意时刻都安全。

　　回到互联网世界，估计熟悉互联网的人会说这个问题很容易解决啊，我们只要把自己的稿件或相片等数字资源上传到某个互联网公司的服务器，那里有上传时间，相当于就把这个稿件盖上时间戳了，盖上时间戳？这个听起来好像正是上面提到的将某事件贴上时间标签。这就好比在以前没有互联网的年代，我们把自己的稿件封进信封然后寄给自己，然后不拆开，那么上面的时间戳就能证明这个时间戳之前我就已经拥有这份稿件了。但是我想问问你觉得把自己原稿件全盘放到别人的服务器上面你能放心吗？你不仅不能保证自己的原稿不会被盗取，可能是黑客，也可能是服务器管理员；而且你不能保证互联网公司服务器被黑客入侵更改了记录的时间，那这个盖上的时间戳就不能作为证据了。总之，自己手里拿着稿件总是比放在别人的服务器上面安全。

　　好吧，接着我要想一个办法，既不用把我的原稿放到别人的服务器上面，同时也可以完成我的稿件时间证明。看看具体操作：

　　第一步，我们到网上去下载一个哈希运算工具，这个工具比较常见，一般使用SHA256算法即可，此算法是国际公认安全算法。笔者下载的工具如上图①，这个工具支持的算法比较多，我这里只要勾选SHA256即可。

　　第二步，选择需要被证明的数字资源，可以是任何类型的文件、照片、软件等等，只要是以数字形式保持的所有资源。假如我桌面上有一个需要保护的文档。

　　第三步，开始计算这个文件的哈希值，我运算出来的结果是5684549d71047df89b73ade87b7ed9549b4b3037f2f704accd47b5417b0cf32d .

　　第四步，也是比较关键巧妙的一步，我们把第三步得到的运算值（这里是5684549d71047df89b73ade87b7ed9549b4b3037f2f704accd47b5417b0cf32d）发到我们常用的社交网站上，可以是博客，微博等等。我选择发到我个人的博客上，上面包含了时间和运算值，至此完成了我的文件存在证明，相当于把我的数字资源盖上了一个时间戳。这下算是大功告成，我的文件已经受到这个博客系统的存在证明了。当然，如果你还希望更多的系统帮你证明你还可以发新浪微博、腾讯微博等等，发越多地方表示越多系统帮你证明。

　　第五步，新建一个目录，建议命名包含运算值，再把保护文件放进去，这样就不会搞混，我们把稿件进行封存并复制一个复件，假如以后我要对改动就直接改复件即可。我们要清楚的是除非把文件改得面目全非，否则我们无需重新将文件盖上时间戳。

　　上面完成对数字资源时间戳证明的原理是什么呢？如下图，SHA256属于哈希算法的一种，不同的字符串作为输入，经过SHA256运算后都能保证全世界唯一，简单点说它的作用就是把任何一串数字映射成全世界唯一的数字，范围在0到2^256，也就是将任何一个文档都创建一个唯一的标识。反过来说，这个唯一标识就可以用来代表你的指定的文档。做这么个运算有一个很重要的作用：不用暴露你的文档的原稿内容。而我们把这个唯一标识发表到博客，那么通过博客的时间即可推出这个指定文档在此时间前已存在。

　　如果你还想加强安全，可以在做哈希运算时加入一个密钥（盐值），这个密钥自己千万不能忘记了，可以看到运算结果已经变了，引入了密钥，毫无疑问更加安全。

　　以上便是我要跟大家分享的数字资源版权自我保护方法。感谢您读完本文，假如您经常写作投稿，您可以考虑使用这个方法，您也可以推荐给经常写作投稿的朋友，多一点的保护措施将在关键时刻保护你的合法权益。

　　来源：投稿，作者：汪洋之舟，此方式由笔者首创。

评论《文章照片等数字资源版权自我保护方法》的内容...

微博：新浪微博 - 微信公众号：williamlonginfo
月光博客投稿信箱：williamlong.info(at)gmail.com
Created by William Long www.williamlong.info

20世纪40年代十大标志性照片

Wed, 27 Nov 2013 14:09:26 CST

译者：熊猫小杨阳原文地址： all-that-is-interesting.com

希特勒在巴黎，拍摄于1940年

这张照片是二战期间德国军队占领巴黎后照的，记录了希特勒和他的亲信们巡视战果的场景，这是二十世纪四十年代二战期间最具标志性的一张照片。

文尼察最后的犹太人，拍摄于1941年

这张具有震慑力的照片是在一名德国别动队的士兵的相册里发现的，记录了纳粹分子杀害乌克兰首都文尼察最后一名犹太人的场景。照片的名字来自其背面的标签，简要地向人们展示了发生在文尼察的大屠杀：居住在那里的28000名犹太人无一幸免。

华沙犹太区的起义，拍摄于1943年

这张拍于1943年的照片是二战时期最著名的照片之一，它记录了德国纳粹分子引发的恐惧。照片上展示了纳粹党对华沙犹太区的摧毁，而这个地方是成千上万犹太人逃离纳粹分子迫害的避难所。照片最有冲击力的地方是前景里高举双手满面惊恐的小男孩，他被迫离开自己的藏身处。

诺曼底登陆日，拍摄于1944年

这张有代表性的照片是罗伯特·卡帕（Robert Capa）在诺曼底登陆日拍的，记录了二战期间浴血奋战的双方在奥马哈海滩对峙的场景。这张照片很模糊，看起来很怪异，可能是某个心急的助手在洗照片时不小心将底片融合在一起造成的，这反倒突出了战争的喧嚣和阴魂不散的感觉。。

抗战胜利日，拍摄于1945年

这张有代表性的照片记录了二战停战宣布后整个美国都在狂欢的场景。跟大家想的不一样，画面上接吻的两个人不是情侣，这名士兵由于太过激动，在时代广场疯狂地亲吻了许多女士--这名幸运的护士只是其中之一。

德国国会大厦上挥动的旗帜，拍摄于1945年

这张照片是叶甫盖尼•哈尔岱（Yevgeny Khaldei）1945年2月在苏军攻克柏林后拍摄的，记录了苏联士兵爬上德国国会大厦屋顶挥动苏联国旗的一幕。这张照片是战争中最著名、最有代表性的照片之一，它之所以如此著名是因为攻陷这栋具有历史意义的建筑象征着纳粹德国的毁灭。在国会大厦周围进行了漫长而血腥的战斗后，苏联军队攻占了柏林。

硫磺岛上升起的旗帜，拍摄于1945年

这张获得普利策奖的照片是乔·罗森塔尔（Joe Rosenthal）拍摄的，记录了二战期间硫磺岛战役中爱国的美国海军陆战队成员将美国国旗插到硫磺岛制高点折钵山（Mount Suribachi）的场景。照片上出现的士兵一半都在那次战役中牺牲了。

日本广岛的原子弹爆炸，拍摄于1945年

这张意义深远的照片记录了八月六日那天日本广岛上原子弹爆炸时的场景。这是到当时为之美国用的第二颗原子弹，照片上的蘑菇云造成的毁坏是十五万人或死或伤。

第一台计算机的问世，拍摄于1946年

第一台计算机的照片是1946年2月公开的，这台计算机由18000个真空管和不计其数的线组成，功率是170000瓦，占用了一个1500平方英尺的房间。

原子的达利，拍摄于1948年

摄影师菲利普·哈斯曼（Philippe Halsman）用这张超现实主义的照片表达对新原子时代和萨尔瓦多·达利超现实主义作品《Leda Atomica》的敬意。这张怪异的照片是由跳跃的人、被扔出去的猫和被泼出去的水组成的。这次拍摄花了6个小时，28次跳跃和各种助理不停的向空中扔猫和泼水才完成。

使用ImageMagick幫照片加上拍照時間浮水印

Wed, 19 Mar 2014 22:24:34 CST

最近挑選了一些小朋友的照片要沖洗出來給老人家翻看，為了方便辨識拍照的時間，因此想把拍照日期以浮水印的方式加到照片上，搜尋了好一陣子，沒想到免費的加浮水印的圖形工具、還要能加上檔名或拍照時間的還真難找。Windows最終找到一個功能頗齊全的 ImBatch，在Linux裡則發現 ImageMagick功能超強，而且還有Windows、Mac OS X、iOS等版本，最後就使用ImageMagick來處理了。

ImageMagick功能介紹

ImageMagick是在命令行操作的工具集，由多個執行檔組成，主要功能就是轉換、編輯與組成圖形（Convert, Edit, And Compose Images）。浮水印要使用的是convert；命令格式是：

convert 你的圖片檔名.jpg -font Arial -pointsize 72 -fill yellow -gravity SouthEast -annotate +100+100  %t 轉換後的圖片檔名.jpg

參數說明

-font: 指定使用的字形，在Linux會找不到，可以不指定
-pointsize: 使用72點的字體大小
-fill: 文字的前景顏色
-gravity: 文字的輸出位置，東南方就是底端右側
-annotate: 要輸出的文字內容屬性，+100+100是邊界位移的畫素點數，%t是沒有副檔名的圖片檔名，也可使用圖片的日期資訊：%[exif:datetime]、%[exif:dateTimeOriginal]等，能使用的字元參數值可以參考 ImageMagick: Format and Print Image Properties

批次處理

convert *.jpg -pointsize 72 -gravity SouthEast -fill yellow -annotate +100+100 %[exif:datetime] converted_%d.jpg

輸出檔名裡的%d會變成由 0 遞增的數值，如converted_0.jpg、converted_1.jpg、converted_2.jpg等。

輸出成品範例

參考

＃＃

您可能也會有興趣的類似文章

將圖片批次加入浮水印的工具：TSR Watermark Image Software (0則留言, 2010/06/06)
使用Ant-Renamer批次重新命名照片檔與影片檔 (0則留言, 2014/02/06)
取得Picasaweb原尺寸圖片的方法 (2則留言, 2012/11/03)
Dropbox App 1.5增加了自動上傳照片檔的功能 (0則留言, 2012/06/16)
[Xuite] 在Xuite中使用上傳的圖片 (0則留言, 2005/04/15)
挺不賴的Windows Live Writer的圖片插件：Polaroid Picture (3則留言, 2008/11/12)
Picasa 圖片整理工具 (0則留言, 2005/01/19)
ZScreen：一氣呵成的單鍵「抓圖與傳檔」工具 (7則留言, 2010/01/24)
[Xuite] 變更頁首(Banner)的圖片 (修正) (1則留言, 2005/04/09)
[Sites] 圖片網站：Open Clip Art Library (1則留言, 2005/08/08)
兼具功能性與方便性的螢幕擷取軟體：Screenpresso (3則留言, 2010/01/17)
使用Word 2010 Beta/2007寫Blog文章 (6則留言, 2010/01/19)
DOS命令使用技巧1：最快把文字檔案貼入剪貼簿的方法 (0則留言, 2010/02/27)
使用Chrome應用程式StackEdit線上編寫Markdown文件 (0則留言, 2013/07/12)
[Reference] 插入圖形檔案時使用的樣式 (0則留言, 2005/02/22)

The post 使用ImageMagick幫照片加上拍照時間浮水印 appeared first on 簡睿隨筆.

Snapseed：来自谷歌的移动设备照片处理神器

Mon, 10 Dec 2012 15:48:07 CST

在这个自拍无比流行的时代，我们天天都要和照片打交道。虽然手机摄像头做得越来越强大，但也总有不让人满意的地方。于是，各种拍照APP横空出世，让我们在拍照时进行特效添加，修改图片等。小编今天为大家推荐的就是一个来自谷歌的照片处理APP——Snapseed。其实之前用iPhone的机友应该就听说过这货，号称iOS上的金牌图片APP，受到很多专业摄友的欢迎。不过之前一直没出Android版本，现在被谷歌收购之后推出了Android版本，并且从前天开始在iOS平台彻底免费了，可以说是让专业摄友沸腾了一把。

以小见大，说说细节

其实也不用小编多说，只要报出谷歌的名字，就已经足以说明这货的质量了，一群技术极客做出来的APP能差了么？但是谷歌的APP一直都有一个很大的问题，即交互UI并不是很理想，他们做的东西一直都是技术上很超前，体验上比较落后。Snapseed是否也有这样的问题呢？小编带着大家一起来看一看。

如果不是初始画面上“Google+”几个大字，小编还真不能相信这么一个好看又贴心的APP是出自谷歌之手。因为这货的整体UI非常不错，而且在每一个需要操作的界面，注意是每一个需要操作的界面都会有图形与文字说明。这已经是以前谷歌的APP不可能出现的了，所以我们有理由相信，在使用体验上，Snapseed绝对不会比同类APP差！

上面都只是停留于表面的肤浅感觉，一个牛逼的APP，绝对不会只是好看而已，它必须要有其技术领先的地方。接着在第一个操作时，小编就发现了这货的不同之处。我们要处理图片肯定要先导入图片。通过左上角的按钮进行添加，我们就看到这货比同类APP多出一个添加渠道。机友们不要不以为然，用了这么多的类似APP，这是小编第一次看到有“粘贴图像”这个选择。虽然这只是小小的一点，但是以小见大，我们可以看出谷歌在技术方的实力确实毋庸置疑。

用事实说话，小编操作给你看

以小见大的说了下谷歌的实力，可能有些机友还是觉得那也没什么大不了的。那么小编现在给大家说说我们用这货来处理照片的方法，在这个过程中，请大家自己去体会去衡量一下Snapseed的水平吧。选择了图片之后，下面就会出现一排处理选项，虽然都是英文但是我们可以试着看一看每一个的用处。而这里的操作，就回到小编前面说过的，每一个选项进去，我们都能看到文字与图片的简单说明，怎么操作一目了然。

步骤上来说，其实也很简单。小编试了下，要用它处理照片仅仅只需要4步就可以完成：

第一步：选择导入图片的方式导入图片

第二步：选择我们想要的处理操作

第三步：调试各项数据，以达到照片的最优效果

第四步：保存或分享至社交网络

简单地操作，加上超过10种的处理选择，无论机友们是要做出黑白效果、LOMO效果还是移轴效果都毫无压力。下面小编就放出我自己试着做的移轴效果对比图，具体操作方法就是上面说的，导入照片之后，选择移轴处理项目，然后调整模糊数值等数据就可以了。做完之后，我们就可以选择右上角的分享了，在这里除了能分享到微博之外，还可以把它分享至谷歌自家的社交网络“Google+”中去哦！

总结

小编在使用Snapseed的过程中，总的感觉是这货有一种谷歌的基因，都是表面上看着不显山不露水，但只有实际使用才能体会到其技术含量的强大，比如可以在各个滤镜中调整数值来达到不一样的效果，任何一个显示效果的展现都是可以自己进行微调的。这比起其他同类APP只能用固定死的滤镜效果强了太多。要真的领略Snapseed的强大，小编还是推荐机友们亲自下载了试试！

# 每日应用推荐#栏目由爱扑GO与最科技联合出品，内容由爱扑GO提供。转载请注明出处： http://www.zuitech.com/22179.html

最科技为你推荐：
美丽说：扮靓老婆计划，给她推荐吧！	节假日随身走：周末特辑之日历APP横向评测	芒果英雄：想吃芒果味的切糕吗？先来合体吧！	手势天气预报：360度无死角看天气	#每日应用推荐#TipSkip：轻巧设备即可切换音乐
无觅

Google+ 推出超強照片編修、加工、特效強化工具（CREATIVE KIT）

Fri, 28 Oct 2011 10:31:55 CST

很久之前曾經介紹過 Picnik 這網站，它的主要功能就是提供一個線上圖片編修、照片特效與強化工具。後來 Picnik 被 Google 買走了，整合到了 Picasa 網路相簿的編輯功能裡去了，是相當多人愛不釋手的好用工具。

今天看到 Google 似乎把 Picnik 圖片編修、特效調整工具修改後整合進 Google+ 去了，當我們在 Google+ 上傳照片之後，可以直接點「編輯」進行圖片翻轉、自動修正或使用「CREATIVE KIT」來進行更詳細的圖片編修、翻轉、裁切、修改尺寸、套用特效、加文字與色彩強化...等等調整，功能相當多且好用，是個非常棒的超實用工具。

繼續閱讀 »

45张不错的红外摄影照片

Sun, 30 Oct 2011 06:30:08 CST

不知道有没有人在玩红外摄影呢？今天分享：45张不错的红外摄影照片，希望其中有你喜欢的，或者可以给你带来灵感的。

The Winter Solstice at Midnight in a Perfect World

Image Credit: Darth Bayne

The Fisherman

Image Credit: Roie Galitz

A Better Day

Image Credit: Orange Bread

Leica M8

Image Credit: Claudio Tizzani

Tropical Garden

Image Credit: Michi Lauke

Blue Sky

Image Credit: Dave Deluria

Infrared HDR Palmer Park Colorado Springs

Image Credit: Brokentaco

The Invisible House

Image Credit: Dingodave

Winter Expedition To Disney’s Everest

Image Credit: Tom Bricker

The Photographer

Image Credit: Thaib Chaidar

Butterfly

Image Credit: gary99099

Palm Springs

Image Credit: Talke Photography

The Japanese Garden in Infrared

Image Credit: lrargerich

Mushroom Tree infrared

Image Credit: Michi Lauke

Dresden Zwinger in infrared

Image Credit: Torsten-Hufsky

Mirror of Ice

Image Credit: Nxxos

Infrared Horse

Image Credit: Vlue

Fairy Tale

Image Credit: Paul

Swiftcurrent Lake and Boat Dock

Image Credit: Bill Gracey

Smith Rock Sunrise-Infrared

(...)
Read the rest of 45张不错的红外摄影照片 (168 words)

如果你喜欢创意悠悠花园的文章，可以收听我们@emilo,或者订阅我们的rss

如果你的订阅器出现防盗链的提示，请通过邮件emilo@vip.qq.com通知我们你的阅读器域名！

推荐本站所使用的空间提供商

2011年最令人驚訝照片選

Tue, 13 Dec 2011 16:45:01 CST

由《時代》雜誌 (TIME) 選出了2011年最令人驚訝的照片，共四十多張，這裏挑選了一部份與大家分享，回顧這個風雨飄搖的2011年。

1. 在尼加拉瓜首都馬納瓜的鬥牛節中，一隻猴子騎著一頭牛出場。

2. 在紐西蘭基督城發生了 6.3 級大地震，造成接近400人死傷，下圖火車軌亦被大地所扭曲。

3. 在蘇丹一個牧場，一名男子正用牛尿來清洗自己。

4. 在美國加州南部，鹽田上一棵枯死的橡樹，被滿月所照亮。

5. 在西班牙狂歡節上，一名男子戴著面具，穿上動物內臟，躺在地上，以怪異的服飾慶祝春天到來。

6. 由歐洲太空人Paolo Nespoli於國際太空站拍攝到的照片，位於阿根廷的巴伊亞阿內加達。

7. 在日本東北部的仙台，受地震及海嘯襲擊後兩天，一名老婦人的屍體被發現於她自己的屋內。

8. 在日本宮城縣，受地震及海嘯所影響，一所寺廟正如下圖般卡在樹林中。

9. 在象牙海岸的阿比讓，一些士兵正在受訓，他們卻沒有拿著武器。

10. 在美國德州，猛烈的山火燒毁了大量房屋，一些熔解了的金屬流向四處。

11. 在古巴的卡馬圭，一隻名為「Yeti」的犬隻，不但餔育自己的子女，還有14頭豬。

12. 在美國德州，大火摧毀了超過 600家房子，於水塔四周也被燒焦。

13. 一架飛機穿過一道強光，這強光是紐約為了911事件十週年，所發射的「紀念之光」。

14. 在南非，一隻黑犀牛正被軍用直昇機運送，遷至15哩以外的新居，以避開來自非洲各地的偷獵者。

15. 來自瑞士的 Freddy Nock，走在吊車的電纜之上，並前進了995米，打破自己保持的世界紀錄。

16. 墨西哥一名犯人，因非法持有槍械被判入獄二十年，其女友探監時把犯人放進行李箱企圖越獄，結果事敗。

Source: Time Lightbox

Perfect365 臉部照片美容整形軟體，一秒鐘神奇自動變臉

Sat, 12 Nov 2011 08:58:26 CST

或許你還是可以用Photoshop慢慢幫照片裡的人修去皺紋、美白皮膚、除掉雀斑、抹掉黑眼圈，甚至微調眼耳鼻口等臉型，但是，如果有「專業的」美容整形軟體可以更快完成上述的人像照片修圖，直接選擇你要的整形項目就能快速美化臉部，是不是更方便？而這就是今天要介紹的「Perfect365」。

Perfect365某種程度上可以說是一個很神奇的軟體，因為它把操作介面做得很簡單，並且可以偵測臉部各種位置，讓軟體有辦法幫你自動調整眼、耳、鼻、口、皮膚和臉型，而不需要自己辛苦的微調。例如你只要點下美化眼型，就能看到照片中人物的眼睛立刻炯炯有神。（或含情脈脈？）

而且Perfect365基本上是一款免費軟體，裡面所有的整形美容功能都可以使用，不過免費版最終只能儲存600x600的大頭照圖檔，如果想儲存原始解析度圖檔，那麼必須購買付費版。但是免費功能已經足夠你製作出一張「以假亂真？？」的漂亮網路大頭照了。

Perfect365：http://www.perfect365.com/index.html
Perfect 365 windows版軟體下載：http://www.perfect365.com/download.html
相關修圖軟體：
InstantMask 簡單直覺幫照片聰明去背的免費修圖軟體
FotoSketcher 2.0 免費相片特效編輯軟體，解放你的藝術家靈魂
LiftMagic 線上免費大頭照美顏工具，比照相館更專業的數位抗皺除斑
Paint.net 3.5 簡單好用免費修圖軟體，自動化編輯數位照片特效

我們這裡以windows版軟體為例，下載Perfect365後，安裝並啟動軟體，接著點擊〔Open Photo〕開啟你的照片，這時Perfect365會自動辨識你照片中的人臉，並鎖定人臉部分開始整形美容編輯。

進入編輯畫面後，可以看到右方是手動式的整形美容細節選項，而左方是預設的各種「套裝」美化樣板。

透過右方的手動式選項，我們可以把皮膚、眉毛、眼睛、鼻子、嘴巴、臉型等等全部好好整一遍，而且這些功能選項都是為了臉部美容而設計的，所以操作起來很直覺，例如「Remove circle」就是去除黑眼圈。

很多選項裡還有細部微調功能，不管是輕重緩急或是各種顏色，你都能慢慢調出自己覺得最漂亮的表現。

而所有的改變都可以在中央圖區即時預覽。

左方的樣板就不用說了，直接點擊便能套用。

在軟體編輯介面上方的〔Adjust Key Point〕，點擊後人臉上會出現各種節點，讓我們可以更細部的微調小地方的整形美容。

而軟體右上方的「B/A」，可以開啟舊照片、新照片的對比模式，讓你看看到底改變有多大？

最後完成編輯時，點擊右下方的儲存就能匯出照片，不過，免費版的Perfect365只能讓我們儲存600x600的大頭貼。

Perfect365把人像照片的整形美容變得很簡單、很新奇，推薦大家可以玩玩看。