月光睡在树梢上

Tuesday, November 11, 2014

[Python] Plot a Gaussian and overlay with an image

x,y = np.random.multivariate_normal(mean, cov, 9000000).T
x = x + center_x
y = y + center_y

heatmap, xedges, yedges = np.histogram2d(x, y, bins=(640, 480), range=[[0, 640], [0, 480]])
extent = [0, 640, 0, 480]

# convert heatmap to image
heatmap = heatmap / max(heatmap.flatten())
print max(heatmap.flatten())
heatmap_im = Image.fromarray(np.uint8(cm.jet(np.transpose(heatmap))*255))

blend_im = Image.blend(im.convert("RGBA"), heatmap_im, 0.4)
blend_im.save("blend.png", "PNG")

[Python] Conversion from matplotlib figure to PIL image

def fig2img ( fig ):
"""
@brief Convert a Matplotlib figure to a PIL Image in RGBA format and return it
@param fig a matplotlib figure
@return a Python Imaging Library ( PIL ) image
"""
# put the figure pixmap into a numpy array
buf = fig2data ( fig )
w, h, d = buf.shape
return Image.fromstring( "RGBA", ( w ,h ), buf.tostring( ) )

def fig2data ( fig ):
"""
@brief Convert a Matplotlib figure to a 4D numpy array with RGBA channels and return it
@param fig a matplotlib figure
@return a numpy 3D array of RGBA values
"""
# draw the renderer
fig.canvas.draw ( )

# Get the RGBA buffer from the figure
w,h = fig.canvas.get_width_height()
buf = numpy.fromstring ( fig.canvas.tostring_argb(), dtype=numpy.uint8 )
buf.shape = ( w, h,4 )

# canvas.tostring_argb give pixmap in ARGB mode. Roll the ALPHA channel to have it in RGBA mode
buf = numpy.roll ( buf, 3, axis = 2 )
return buf

[Python] save a figure in matplotlib with figure border removed

def SaveFigureAsImage(fileName,fig=None,**kwargs):
''' Save a Matplotlib figure as an image without borders or frames.
Args:
fileName (str): String that ends in .png etc.

fig (Matplotlib figure instance): figure you want to save as the image
Keyword Args:
orig_size (tuple): width, height of the original image used to maintain
aspect ratio.
'''
fig_size = fig.get_size_inches()
w,h = fig_size[0], fig_size[1]
fig.patch.set_alpha(0)
if kwargs.has_key('orig_size'): # Aspect ratio scaling if required
w,h = kwargs['orig_size']
w2,h2 = fig_size[0],fig_size[1]
fig.set_size_inches([(w2/w)*w,(w2/w)*h])
fig.set_dpi((w2/w)*fig.get_dpi())
a=fig.gca()
a.set_frame_on(False)
a.set_xticks([]); a.set_yticks([])
plt.axis('off')
plt.xlim(0,w); plt.ylim(h,0)
fig.savefig(fileName, transparent=True, bbox_inches='tight', \
pad_inches=0)

Tuesday, August 12, 2014

说走就走的波多黎各

"流年似水，太过匆匆，一些故事来不及真正开始，就被写成了昨天；一些人还没有好好相爱，就成了过客。" - 林徽因

想去波多黎各，多半还是因为马尔克斯笔下那片沼泽地圣胡安（《霍乱时期的爱情》）。任何一个有历史的城市，都藏着诸多感动人的故事，圣胡安（San Juan）也不例外。作为波多黎各最大、最古老的城市，这里从殖民地时期的一开始就成为西班牙人从大洋彼岸到美洲大陆征服之路的第一站。想想波多黎各（Puerto Rico）在西班牙语中的意思：Puerto就是英语中的Port（港口），Rico就是英语中的Rich（富饶），直译过来就是富饶之港，一看就是典型的大航海时代殖民地名字的取法，再如象牙海岸（科特迪瓦），黄金海岸（加纳），等等。我一直觉得翻译是一门艺术，要把音的和谐和义的传达完美结合起来，确实是很难的一件事情。

“说走就走”，其实仅仅是对于旅行的行程计划而言，而对于圣胡安老城以及波多黎各的向往，则是心存已久了。在美国的小伙伴们都知道，美国大部分的城镇清一色的相似，历史底蕴的缺乏强烈限制了大家出行的选择。对于喜欢自然风光的朋友来说，美国是个绝佳的地方：地广人稀，从阿拉斯加的极光，到旖旎多姿的黄石，再到迈阿密和Key West的海滩，各种各样的风景让人流连忘返。可是波多黎各却是这样一个神奇的地方，作为美国的海外领，它保存了绝大部分西班牙殖民地时期的风土人情（当地人的第一语言是西班牙语），但又不需要额外办理签证，这为常年驻扎在北美大陆的同学们提供了一个不一样的旅行目的地。

7月21号，博士论文答辩结束，我终于长舒了一口气，23号订了7月31号从Indianapolis到San Juan的机票，8月5号返回。由于订的较晚，所以机票大概500刀左右，如果提早预定的话应该可以到400左右。然后就是酒店，我直接参考之前去过的同学住的地方，订了在San Juan Downtown的At Wind Chimes Hotel，100刀一晚（还是订晚了的缘故，早订的话房间多，会便宜些）。最后是租车，直接订好了在San Juan机场取／还。

OK，流水账开始。

Day 1 （7月31号）：

飞机是中午12点从Indianapolis起飞，下午1:30到Atlanta，然后从Atlanta转机再飞三个多小时到San Juan。

圣胡安的机场名称叫 Luis Muñoz Marín International Airport，是以现代波多黎各之父（Father of Modern Puerto Rico）Luis Muñoz Marín的名字命名的。下面机场图片是当天晚上九点抵达机场所摄。

然后是到机场的租车公司前台提车，等到到酒店已经快晚上10点了。一路上没吃好，在Yelp上搜到酒店附近的一家Bar，买了一分海鲜墨鱼汁意面。

自己不算是吃货，但是加勒比海的美食实在让人无法抗拒，后面会有更多关于食物的图片。

Day 2 （8月1号）：

今天逛老城。老城比较小，在靠海边的位置，离我住的地方开车要15分钟到20分钟左右。老城最著名的景点就是El Morro了。沿着城边靠海筑起来的城墙，蜿蜒伸展，一直把圣胡安严严实实的包裹起来（可见这里绝对是一个军事要塞）。El Morro已归入美国National Park Service管理，门票五块钱（请对比一下国内旅游景点收费情况）。

孤独的瞭望塔。

城墙外的墓地。

五彩缤纷的老城。

背面是瞭望塔，再后面是大西洋，最远处是西班牙。

古老的市政大厅（La Alcaldía）

诗人咖啡馆（Poet‘s Passage）。非常文艺的一个小咖啡馆，每种咖啡都起了和诗歌相关的名字。每张桌子旁边有一个小抽屉，里面装满了来来往往客人们写下的片段文字。一定要点一杯加冰的玛奇朵，非常赞。

整个一天都在老城，晚饭吃了Puerto Rico当地著名的一种食物，叫Mofongo。

同时要了两大杯Mojito，这下可不得了，直接醉过去了。。完全不能走路，更别说开车回酒店了，于是在餐馆一直坐着，热心的服务员不停的给我茶水喝，两个小时之后我才离开：）

Day 3（八月2号）：

今天起的很早，本来是想直奔码头，去C岛逛逛海滩，没想到一大早就开始下雨，上岛的渡轮也全部取消。赶紧查了下天气，才知道今天有storm来临。后来听当地人讲，我来之前波多黎各已经干旱了两个月了，难不成storm是专门为了欢迎我的么。

立即改行程，去附近的super max吃早饭，顺便查了北线的几个海滩。我心想，storm既然从东北方向来，那我就一路往南开到Ponce去。后来的事实证明，这完全是一次错误的选择，导致我差点困在山里出不来。。。

OK，路线是从San Juan出发，向西开，经过Cerro Gordo、Tortuguero、Marchiquita几个海滩之后向南从波多黎各中部穿过去直奔Ponce。首先贴几张这些海滩的照片，雨水伴随着海水一起激烈地拍打着海滩，别有一番味道。

大约在中午的时候，我开始往南走，于是悲剧开始了。。。北线海边的雨其实并不算大，但是完全没想到波多黎各中部是山区，全部都是山路，当我开进PR-615的时候就开始觉得不对劲了，路上只有我一辆车，瓢泼的大雨，蜿蜒陡峭的山路，雨刷开到最大也完全抵挡不住雨水的冲击。然而最艰难的还在后面。为了安全起见，我把手机上的google maps和车载GPS同时打开，双导航，可当我开到PR-66xx时，心里着着实实的紧了一下：unpaved的土路，只容得下一个车身的宽度，陡峭的斜坡。。更可怕的时GPS把我导航到了一个deadend。。。瓢泼大雨中一个人在车里折腾半天，终于还是觉得要先保住自己的小命要紧。于是沿着来时的路往回开，因为这时是下坡，所以开的非常非常慢，非常非常小心：一个闪失可能就真的让自己挂掉。。。

这里顺便吐槽一下美国公路的标记方法，统统都用数字，完全看不出每条路的地形。我曾经自驾过法国和瑞士，那里的公路除了用数字，也有字母，用来标记这条路是在山地还是平原。这方面美国佬需要学校一下！

下面是当时的手机截图，蓝色的点是我最终开始决定向北返回的地方。

庆幸的是，下山途中路过一个小酒吧，里面有八九个躲雨的人，我把车横在路边的土坡上，飞快的钻了进去。感谢热情的波多黎各大叔们，让我在bar里躲了一个小时雨。下午三点，雨开始变小，我于是下山返回San Juan，经过两个小时的高速路终于抵达酒店。

Day 4（8月3号）：

雨后的圣胡安突然变得特别宁静。被告知渡轮还没有恢复运行，而且 El Yunque热带雨林公园也受storm影响仍未开放，于是决定今天继续逛老城。

首先来到第一天miss掉的圣胡安老城城门（Puerta de San Juan）。这里是圣胡安老城唯一的城门，直接面向大西洋，是西班牙人由此上岸的必经之路。

城门外就是浩瀚的大西洋：）

从城门出发往里面走，经过两个block就到了圣胡安大教堂。碰巧的是，我经过这里的时候正好是中午12点，并且是周日做礼拜的时间，挤满了人。

中午在老城吃了一份西班牙海鲜饭（Paella），很赞。

下午把老城的很多gift shop和antique shop逛了个遍，买了些纪念品，然后就跑到peot‘s passage要了一杯咖啡对着窗户发呆：）

傍晚来到老城附近的 Balneario El Escambrón 海滩。

Day 5（8月4号）：

今天是非常精彩的一天！如愿以偿的登上了传说中的C岛（Culebra），和世界第二美的海滩亲密接触。很幸运的偶遇从加州来波多黎各旅游的一家五口美国人，非常nice的一对夫妇，和我爸妈年纪相仿。

big family 大合影，这里的海水真的太干净，太美了。情不自禁地向海里走去，走到越深处，浪打在身上越重，前进就越是艰难。

喂食海鸟的美女们。

Day 6（8月5号）：

中午的飞机，一大早起来开着车在城里逛，跑到邮局给同学寄去了明信片。

美丽的波多黎各，再见。

Friday, February 14, 2014

VI 自带的spell checker

:s spell

才发现的。。很好用！

Sunday, September 1, 2013

[zz]数码摄影中的测光方法和测光技巧

一、相机的测光原理

　　相机（数码和各种胶片）的测光原理并不复杂，最重要的是我们要明白，相机的测光系统（或测光表）是以何为测量基准的！通俗地讲，就是相机在测量一个场景的光线时，它怎样“想”自己看到的东西？

　　记住：所有的相机在测光过程中，会将“看到”的所有物体都默认为反射率为18%的灰色（摄影的专业术语叫“中级灰”），并以此作为测光的基准。也就是说，在相机的“眼”中，所有的被摄体都是灰色的，曝光的目的是为了正确还原这种灰色。

　　为什么是这个特殊的18%灰？因为18%灰与人皮肤平均反射光（16～20％）的色调一样，而人是我们最常拍摄的对象。（其它物体的反射率，如银是96％，绘图白纸75％，纯黑是3％等。）

　　测光表工作时，要看被摄体的反射率是否为18%，如果反射率是18%，那它测量出来的数值就十分准确了，按此数值曝光，被摄体的色彩和影调就会得以真实地还原，所以，对我们的皮肤、平常的色彩斑斓的景物来说，这种以灰色基调为还原标准的曝光是非常准确的。

　　如果被摄体的反射率不是18%，那么相机测光系统测量出来的数值就不准确，若直接按此数值曝光，画面的影调和色彩就会出现失真：像拍摄白茫茫的雪原、黑漆漆的煤田，相机也把它们当作灰色来还原，直接对着它们测光聚焦，往往会拍出灰色的雪和煤。

　　小窍门：数码拍摄中，合理测光的几个小技巧：

　　① 拍雪景，你可以先对着你的手半按下快门，也就是对自己的皮肤进行测光，然后再对种你要拍的雪按下快门，那么雪就是白颜色了。同理，拍摄穿黑衣服的人像，也应先对脸部进行测光，然后再构图拍摄。）

　　② 当拍摄明亮物体时，应采用比测光表推荐的指数高1～2档的光圈，而对阴暗物体则要适当减少曝光量。

　　③ 在阳光很充足的季节拍照，将使照片产生很大的反差，所以必须要对景物的明亮、阴暗部位分别测光，并以两者的平均曝光指数进行拍照。

　　大秘诀：记住下面的一些物质，它们的反射值接近18%，也许对大家在复杂的条件下拍摄非常有用：

　　① 草（割后的草地！），但注意，不是墨绿、特别绿或发黄的草；

　　② 大部分浅绿的树叶或植物叶子；

　　③ 有些、但不是全部树干；

　　④ 旧的、修复的柏油路和混凝土（这个非常有用）；

　　⑤ 长期放置、没有刷油的木材；

　　⑥ 红/棕色的砖，包括水泥墙；

　　⑦ 干树叶。

下图是我依据测光原理，用DC拍的两张PP，以便通俗地说明问题。

同样，黑暗的背景也可能骗过相机的测光，造成错误的曝光，下面两幅照片对比说的就是这个道理。（上图，正确的曝光；下图，曝光过度。注：两幅PP引自相关书籍。）

需提醒大家注意的是，在一个复杂的场景中拍摄，评价曝光是否准确还需视拍摄主题及我们想要突出的拍摄对象而定。除逆光时剪影拍摄外，一般要求，拍摄主体的曝光尽量准确，细节清晰。

    二、相机的测光方式

    由于各类相机的构造和功用不尽相同，因此，与之相适应的测光系统和方式也各有所异。

    目前，几乎所有的数码相机测光方式都采用 TTL （Through the lens）、自动测光（Auto Exposure）系统经过镜头来测光。所以，我给大家主要介绍镜头（TTL）测光的一些基本知识，至于单独测光表测光的技巧得请部落的各位大侠出面给我们上课啦。

    通过镜头（TTL）测光的方式具有携带、使用方便的特点，并在使用滤光镜或近摄皮腔时可以简便、直接地测量出光线经过滤光镜或近摄皮腔阻挡、衰减后的亮度值。基本上，数码相机的测光模式有四种：

    1、平均测光（又名“整体测光”）

    这是最基本的一种测光方式，这种测光方式将被摄体在取景屏画面内的各种反射光线的亮度进行综合而获得平均亮度值。平均测光的特点是使用简单，但测光精度不高，在取景范围内明暗分布不均匀的状况下，较难直接依据测光数值来确定合适的曝光量。尤其是当画面中有大面积的白或黑色物质时，给我们提供的往往是一个不准确的曝光值。

    这种类型的测光系统，主要是在一些低档的入门级数码相机中应用。

    2、中央重点测光（又名“中央均衡测光” Centerweighted averaging metering ）

    中央重点测光主要是测量取景屏画面中央长方形或圆形（椭圆形）范围内的亮度，画面其它区域则给以平均测光，长方形或圆形（椭圆形）范围外的亮度对测光结果的影响较小。至于中央面积的多少，因相机不同而异，约占全画面的20-30%。

    由于是依据画面中央最重要主体的光亮度来读取合适的曝光值，显然，这种测光系统的精度高于平均测光。

    另一种中央测光的形式叫做“底部测光”，与中央测光相似，它是对画面的下半部测光，从而可减少对天空的过多注意而产生的错误。

    中央重点测光系统一般用于中档小型数码相机，这种测光模式较适用于人像写真拍摄。

    3、点测光（Spot metering ）

    点测光的测光范围是取景器画面中央占整个画面约2～3%面积的区域。点测光基本上不受测光区域外其它景物亮度的影响，因此，可以很方便地使用点测光对被摄体或背景的各个区域进行检测。

    点测光具有较高的灵敏度和精度。但不管怎样，一定要记住，要想实现准确曝光，测光对象应该适合18%灰的要求。

    4、矩阵测光（又名“分区测光”、“多区域评价测光” Multi-zone evaluative metering ）

    这种测光模式也称“智能化”测光，是一种高级的测光方式。测光系统将取景画面分成若干区域（不同的相机划分的形状、方式不同），分别设置测光元件进行测量，然后通过相机内的微电脑对各个区域的测光信息进行运算、比较，并参照被摄主体的位置，推测出被摄体的受光状态是逆光还是一般光照，从而决定每个区域的测光加权比重，全部衡量后，计算出合适的曝光值。

    有些相机的矩阵测光系统在决定曝光需要量的同时，还把场景的色彩也计算在内。

    矩阵测光目前较广泛地应用于一些高档数码相机，它能够使相机在各种光线条件下拍摄都取得较好的自动曝光系统。

    强调：弄明白我们自己手中DC的测光方式非常重要！所以，建议大家好好查阅一下手头的说明书，如果说明书介绍不清楚，可在网上查阅相关技术数据或到你买相机的器材店咨询清楚。

    三、不同测光模式下的测光技巧

    ㈠、平均测光模式

    这种测光模式最容易出现错误（庆幸的是，只采取这种测光模式的数码相机越来越少了），因为测光系统对每一个物体的测量，都假定为18%的灰。

    为了防止错误地曝光，拍摄中可以考虑采用以下控制测光的方法：

    1、现在不少数码相机具有“曝光锁定”功能，它的工作方式是，当我们用相机对准拍摄场景中的某一特殊部位（这部分的反光应该相当于10%灰）测光，得到正确的曝光数据后，用曝光锁定控制固定这个曝光条件，然后重新构图，按自己的画面要求取景，最后按下快门。

    2、对于没有“曝光锁定”控制，但具有“手动控制”功能的数码相机，在这种测光模式下，同样也可按此方法拍摄：即靠近现场合适的拍摄主体，让它充满取景器，或者让相机对准反光值相当于18%的其它部分，按这时的曝光值设定光圈和快门，然后回来重新构图、拍摄。

    注：当我们靠近拍摄物体去测光时，不要让自己挡住光线，而且要认准这部分被测光的景物反射值接近18%灰！还有，当测光物体与镜头的距离和被摄主体与镜头的距离不一致时，要注意控制好焦距。

    ㈡、中央重点测光模式

    中央重点测光比平均测光模式更准确，但仍然经常出现上面类似的问题，所以，仍然可以参照前面的测光控制方法和拍摄技巧。

    ㈢、点测光模式

    点测光模式能较好的计算曝光量。我们在拍摄中需要记住的是，寻找取景器画面中光线反射值相当于18%的那些地方，读取曝光量，最好用曝光锁定控制保持住，直到重新构图（如果需要的话）、按下快门。

    注：数码相机在自动拍摄模式下，可先调整镜头准确测光后半按快门，然后移动相机构图、按快门！

    ㈣、矩阵测光模式

    使用矩阵测光模式，差不多可以得到95%左右很好曝光的效果，但即使是这样，也有可能出现被相机“骗”的遭遇。

    此时，我们能做的事情，就是仔细研究一下“失败”的PP，总结经验，然后在遭遇类似拍摄情况时认真调整，补上（或减少）合适的曝光量。

    四、测光复杂情况下的“分级曝光”技巧

    有的时候，由于拍摄现场复杂、光线非常不好掌握，或拍摄时间比较紧张、根本来不及考虑太多的测光技巧。在这种情况下，为了避免错失一生难得的摄影机会，我们可以考虑采用“分级曝光”拍摄。

    “分级曝光”是一项摄影技术，通俗地讲，就是在同一场景中拍摄多幅相同的照片，而每幅照片的曝光设定不是按测光系统测定的曝光值，相对于测光表的曝光值，有的曝光不足，有的曝光过度。

    目前，一些先进的数码相机具备自动分级曝光功能（有些相机在说明书中，将这种技术称为“包围式曝光”）。启用该功能后，DC会连续拍摄三张照片，而这三张照片的曝光量相差一档或者两档，这样，三张照片中肯定会有一张是曝光正确的。

    下面，我们通过举例来更形象地说明“手动控制”拍摄模式下的“分级曝光”技巧：

    假定在一个光线复杂的拍摄场景中，相机的测光指示该场景的曝光值是f8、1/250秒，但我们无法肯定测光是否可靠。于是，可考虑采用下面的“分级曝光”技术拍摄。

    1、首先按测光指示的曝光值设定（f8、1/250秒），拍摄一张照片；接下来，分别改用f11、1/250秒和f5.6、1/250秒各拍摄一张（为了保险起见，还可用f16、1/250秒和f4、1/250秒再多拍两张）；

    2、现在，换到原来设定的f8光圈，改变快门速度，分别用1/500秒和1/125秒各拍摄一张（同理，仍可用f8、1/1000秒和f8、1/60秒再多拍两张）；

    将上面拍摄的各张照片传到电脑上对比分析，我们就能逐渐轻松掌握复杂光线情况下的测光和曝光窍门啦。（由于数码相机的存储特性，多拍并不会造成浪费，嘿嘿，就就是我爱DC的最大理由！）

    提醒：

    ① 在“分级拍摄”情况下，改变光圈或快门的设定时，应注意“景深”的变化。同时，还需防止当相机的快门速度低于1/60秒时，相机的抖动和拍摄物体运动的问题。

    ② 实际拍摄中，可不必按所有的光圈光圈分级，如果我们只是稍微地不确定曝光设定的正确性，用半档光圈分级会更好一些。

    ③ 现在很多数码相机都预设有不同场景拍摄模式（我最近帮同事选购的卡西欧EX-Z40就有“人像、风景、风景中的人像、合成拍摄、预拍、儿童、烛光中的人像、聚会、宠物、花、自然绿、落日、夜景、夜景中的人像、烟火、食物、文字、收集品、黑白、古风、黎明和黄昏”等，整整21种场景模式可供选择！另外，如果觉得你场景不够灵活，还可以选择一张自己拍得比较好的照片，作为“自定义场景”），这样测光时就相对精确多了，求助于它们的帮助，可以得到正确的曝光补偿。

    五、不同受光情况下的测光方法和技巧（有点太专业，我等“菜鸟”级色友看看即可）

    根据光源的性质和照明状况，拍摄时被摄体的受光情况大致有三种：连续光、闪光和混合光。在这三种光照下，测光的方法和技巧是有所区别的。

    ㈠、连续光测光

    连续光的最大特点是稳定及便于观察照明效果，因为，它的测光方法是最多的，通常有机位测光法、接近主体测光法、平均测光法、中性灰卡测光法、被摄体主调测光法、最亮点与最暗点测光法以及多点测光法等。其中，最为实用的是中性灰卡测光法和被摄体主调测光法。

    1、中性灰卡测光法

    中性灰卡测光法是既简便又较为准确的测光法，它将反射率为18%的标准灰卡作为测光对象。用此法测光时，要尽量使中性灰卡靠近被摄体，并与之平行，灰卡正对照相机，与镜头光轴垂直，为避免灰卡反光，可将灰卡稍向前俯。中性灰卡测光法最大的好处是可以避免因对被摄体的测光部位选择不当而产生测光误差。

    摄影小常识：一般摄影器材店都销售“灰卡”，买一个放在自己的相机包里，关键时刻会起作用的！

    2、被摄体主调测光法

    当被摄体的亮部和暗部分布均匀、照明均匀时，测光是很容易的；反之，测光就变得较难了。遇到这种情况，我们一般可采用被摄体主调测光法。该法是对被摄体的主要局部作“点测光”的测光方法，它的操作较简便，测光时的关键是选好被摄体的主调，即是以被摄体的亮部作为主调，还是以中间调部分或暗部作为主调。

    被摄体测光法的优点是能确保被摄体主调部分有良好的层次与细节表现。

    ㈡、闪光测光

    闪光不同于连续光，它只是瞬间发光，因此，使用一般的连续光测光表是无法进行正确测光的，必须考虑带有闪光测光功能的测光表，并且将测光状态置于“闪光测光”状态。

    目前对闪光的测光一般采用入射式测光表测量，测得的数值是闪光照明下反射率为18%的中性灰的曝光值。有关详细技巧可在以后的《数码相机的闪光摄影》中再做专题介绍。

    ㈢、混合光测光

    混合光是指发光性质不同的光源混合使用。它在摄影中其实并不常用，主要是因为不同光源的色温不同，会给被摄对象各区域色彩的准确还原带来困难，另外，性质不同的光源混合使用，尤其是连续光和闪光混合使用，也会给影像的曝光控制带来困难。

Thursday, December 13, 2012

[leetcode] mimimum depth of binary tree

Minimum Depth of Binary Tree

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int minDepth(TreeNode *root) {
// Start typing your C/C++ solution below
// DO NOT write int main() function

if (!root)
return 0;

queue my_queue;
my_queue.push(root);
my_queue.push(NULL);
int depth = 0, min_depth = 9999;

while (!my_queue.empty())
{
TreeNode *front = my_queue.front();

my_queue.pop();

if (!front)
depth++;
else
{
if (!front->left && !front->right)
{
if (min_depth > depth)
min_depth = depth;
}
if (front->left) my_queue.push(front->left);
if (front->right) my_queue.push(front->right);
front = my_queue.front();
if (!front) my_queue.push(NULL);
}
}

min_depth++;

return min_depth;
}
};

[leetcode] maximum depth of binary tree

Maximum Depth of Binary Tree

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int maxDepth(TreeNode *root) {
// Start typing your C/C++ solution below
// DO NOT write int main() function

if (!root)
return 0;

// level traversal

queue my_queue;

my_queue.push(root);
my_queue.push(NULL); // a dummy node

int depth = 0;

while (!my_queue.empty())
{
TreeNode *front = my_queue.front();
my_queue.pop();
if (!front)
{
depth++;
}
else
{
if (front->left) my_queue.push(front->left);
if (front->right) my_queue.push(front->right);
front = my_queue.front();
if (!front) my_queue.push(NULL);
}
}

// reduce by 1 because of the last dummy node
depth--;

return depth;
}
};

Wednesday, December 12, 2012

[leetcode] longest common prefix

Longest Common Prefix

Write a function to find the longest common prefix string amongst an array of strings.

这个简单，差不多一遍通过：）

class Solution {
public:
string longestCommonPrefix(vector &strs) {
// Start typing your C/C++ solution below
// DO NOT write int main() function

if (strs.empty())
{
return string("");
}

// first find the minimum string length
int min_len = strs[0].length();

for (int i = 0; i < strs.size(); i++)
{
if (min_len > strs[i].length())
min_len = strs[i].length();
}

// compare staring at [min_len-1]
int length = 0;
for (int index = 0; index < min_len; index++)
{
bool all_equal = true;
for (int cur = 1; cur < strs.size(); cur++)
{
if (strs[cur-1][index] != strs[cur][index])
{
all_equal = false;
break;
}
}
if (all_equal)
length = index + 1;
else
break;
}

return strs[0].substr(0,length);
}
};

[leetcode] count and say

Count and Say

The count-and-say sequence is the sequence of integers beginning as follows:
1, 11, 21, 1211, 111221, ...

1 is read off as "one 1" or 11.
11 is read off as "two 1s" or 21.
21 is read off as "one 2, then one 1" or 1211.

Given an integer n, generate the n^th sequence.

Note: The sequence of integers will be represented as a string.

class Solution {
public:
string countAndSay(int n) {
// Start typing your C/C++ solution below
// DO NOT write int main() function

string str = "1";

if (n == 1)
return str;

for (int i = 1; i < n; i++)
{
string new_str = "";
int count = 0;
char ch, pre = '0';
bool flag = false;

for (int k = 0; k < str.length(); k++)
{
ch = str[k];

if (ch == pre || k == 0)
{
count++;
}

if ( (k > 0 && ch != pre ) || k == str.length()-1)
{
flag = true;
}

if (flag)
{
// update new_str
char tmp = '0' + count;
new_str += tmp;
if (k > 0)
new_str += pre;
else
new_str += ch;
count = 1;
flag = false;
}

// check the last character
if ( k > 0 && k == str.length()-1 && ch != pre)
{
// we know we have to process the
new_str += '1';
new_str += ch;
}

pre = ch;
}

// update str
str = new_str;
}

return str;
}
};

Monday, December 10, 2012

[leetcode] unique binary search trees

Unique Binary Search Trees

Given n, how many structurally unique BST's (binary search trees) that store values 1...n?

For example,
Given n = 3, there are a total of 5 unique BST's.

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

class Solution {
public:
int numTrees(int n) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
int cache[n];

for (int i = 0; i < n; i++)
cache[i] = 0;

cache[0] = 1;

for (int i = 1; i < n; i++)
{
// compute the count for N = i+1 nodes
int count = 0;
for (int k = 0; k <= i; k++)
{
// assume [0..i] is computed
// pick k as the root
int left_sum = 1, right_sum = 1;

if (k > 0)
left_sum = cache[k-1];

if (k < i)
right_sum = cache[i-k-1];

count += left_sum*right_sum;
}
cache[i] = count;
}

return cache[n-1];
}
};

[leetcode] flatten binary tree to linked list

Flatten Binary Tree to Linked List

Given a binary tree, flatten it to a linked list in-place.

For example,
Given

The flattened tree should look like:

/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
void flatten(TreeNode *root) {
// Start typing your C/C++ solution below
// DO NOT write int main() function

// use a 'pre' pointer to track the predecessor of the current node
// use pre-order traversal

if (!root)
return;

stack my_stack;
TreeNode *pre = NULL;

my_stack.push(root);
while (!my_stack.empty())
{
TreeNode *p = my_stack.top();

// visit p
if (pre)
{
pre->right = p;
pre->left = NULL;
}

pre = p;

// pop current node
my_stack.pop();

// push right and left children into stack
if (p->right) my_stack.push(p->right);
if (p->left) my_stack.push(p->left);
}
}
};

[leetcode] search for a range

Search for a Range

Given a sorted array of integers, find the starting and ending position of a given target value.

Your algorithm's runtime complexity must be in the order of O(log n).

If the target is not found in the array, return [-1, -1].

For example,
Given [5, 7, 7, 8, 8, 10] and target value 8,
return [3, 4].

class Solution {
public:
vector searchRange(int A[], int n, int target) {
// Start typing your C/C++ solution below
// DO NOT write int main() function

// binary search in the given array
int start = 0, end = n-1, mid;
vector result;
bool is_found = false;
int c1 = -1, c2 = -1;

while (start <= end)
{
mid = (start + end) / 2;

if (target == A[mid])
{
is_found = true;
break;
}
else if (target > A[mid])
start = mid + 1;
else
end = mid - 1;

}

if (is_found)
{
// move cursors
c1 = mid, c2 = mid;
while (A[c1] == target && c1 >= 0)
c1--;
while (A[c2] == target && c2 < n)
c2++;
c1++;
c2--;
}

result.push_back(c1);
result.push_back(c2);

return result;
}
};

Sunday, December 9, 2012

用栈操作遍历二叉树的方法

先序遍历。将根节点入栈，考察当前节点（即栈顶节点），先访问当前节点，然后将其出栈（已经访问过，不再需要保留），然后先将其右孩子入栈，再将其左孩子入栈（这个顺序是为了让左孩子位于右孩子上面，以便左孩子的访问先于右孩子；当然如果某个孩子为空，就不用入栈了）。如果栈非空就重复上述过程直到栈空为止，结束算法。

中序遍历。将根节点入栈，考察当前节点（即栈顶节点），如果其左孩子未被访问过（有标记），则将其左孩子入栈，否则访问当前节点并将其出栈，再将右孩子入栈。如果栈非空就重复上述过程直到栈空为止，结束算法。

后序遍历。将根节点入栈，考察当前节点（即栈顶节点），如果其左孩子未被访问过，则将其左孩子入栈，否则如果其右孩子未被访问过，则将其右孩子入栈，如果都已经访问过，则访问其自身，并将其出栈。如果栈非空就重复上述过程直到栈空为止，结束算法。

[leetcode] binary tree maximum path sum

Binary Tree Maximum Path Sum

Given a binary tree, find the maximum path sum.

The path may start and end at any node in the tree.

For example:
Given the below binary tree,

       1
      / \
     2   3

Return 6.

Here I consider a recursive solution. We update the 'val' field of each node with the path sum ending at that node (starting from any one of its descendants). We keep a 'max_sum' variable to save the current maximum path sum. We update this variable using paths going through the node, paths ending at this node, and the single-node path. We traverse the binary tree once, so the time complexity is O(n).

/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:

void max_path_helper(TreeNode *root, int &max_sum)
{
if (!root) return;
else
{
max_path_helper(root->left, max_sum);
max_path_helper(root->right, max_sum);

int left_sum = 0, right_sum = 0;
if (root->left)
left_sum = (root->left)->val;
if (root->right)
right_sum = (root->right)->val;

// update max sum
int sum = left_sum + right_sum + root->val;
int sum_left = left_sum + root->val;
int sum_right = right_sum + root->val;

if (max_sum < sum)
max_sum = sum;

if (max_sum < sum_left)
max_sum = sum_left;

if (max_sum < sum_right)
max_sum = sum_right;

if (max_sum < root->val)
max_sum = root->val;

// compare with child sums and single value at this node
int tmp = 0;
if (left_sum > right_sum)
tmp = root->val + left_sum;
else
tmp = root->val + right_sum;

// update value
if (tmp > root->val)
root->val = tmp;
}

}

int maxPathSum(TreeNode *root) {
// Start typing your C/C++ solution below
// DO NOT write int main() function

// current max sum
int max_sum = -999;

// for each node, compute the max sum of the path starting at this node
// update max_sum using the max_sum's of its two subtrees
if (!root)
return 0;

max_path_helper(root, max_sum);

// finally compare the current max sum with the path sum ending at root
if (max_sum < root->val)
max_sum = root->val;

return max_sum;
}
};

Saturday, December 8, 2012

[leetcode] binary tree level traversal

Binary Tree Level Order Traversal

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:
Given binary tree {3,9,20,#,#,15,7},

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector > levelOrder(TreeNode *root) {
// Start typing your C/C++ solution below
// DO NOT write int main() function

// initialize the result
vector > result;

if (!root)
return result;

queue my_queue;

my_queue.push(root);
// push a dummy node into the queue
my_queue.push(NULL);

// initialize a tmp array
vector tmp;

while (!my_queue.empty())
{
TreeNode *front = my_queue.front();

if (!front)
{
// process a dummy
if (tmp.size() > 0)
result.push_back(tmp);
tmp.erase(tmp.begin(), tmp.end());
my_queue.pop();
continue;
}
else
{
tmp.push_back(front->val);
my_queue.pop();
}

if (front->left) my_queue.push(front->left);
if (front->right) my_queue.push(front->right);

// check if the next node is dummy
front = my_queue.front();
if (!front)
{
// initialize another dummy into the queue
my_queue.push(NULL);
}
}

return result;
}
};

[leetcode] binary tree inorder traversal

Binary Tree Inorder Traversal

Given a binary tree, return the inorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

return [1,3,2].

Note: Recursive solution is trivial, could you do it iteratively?

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

Wednesday, November 28, 2012

Mark Cuban 演讲小结

刚刚去听了Mark Cuban的演讲，Mark Cuban是Indiana的校友，美国商界的精英，曾经已59亿美金的天价将自己的一个IT公司卖给了雅虎，现在是小牛队的老板。和Mark近距离接触的感觉和屏幕上看到的很相似，非常地passionate，言谈举止非常地坚定，说话也非常风趣幽默。简单总结一下这次地收获吧：

1. 创业远远不是只有idea就行的，绝对不是你和一帮兄弟喝着啤酒海阔天空地扯扯淡就能做好的。创业需要的是preparation，也就是说你要对你所要做的东西了解地非常透彻，要做到比任何人都要懂你做地东西。这一点李开复演讲地时候也是常强调的。

2. 有个学生提问时说，“failures are necessary for success”，然后问Mark经历过什么样的失败，才成就了今天的成功。Mark很可爱地说他似乎没经历过什么failure，然后哈哈大笑说“Failures only belong to losers”！其实不管是成功还是失败，最重要地是你从这段经历中学到了什么，有什么样的教训，让你有了怎样地成长。另外，所谓“failure”，可能从来都不存在于“成功”的字典里；相信自己会成功的人才会真正成功。

3. 关于人生理想和自身定位。Mark说自己当时创建公司时，自己的目标就是在35岁之前把公司做大，然后在35岁的时候退休，去做自己喜欢做的事情（比如说现在经营NBA小牛队）。永远不要让你后悔自己的人生，人生每个阶段都有需要去做的事情，不要到老的时候去后悔。

4. 中间有个小插曲。Mark在开场的时候说他曾经投资过无数个公司，别人一封email，即使甚至连人都没见过，他也可能会投资给那个人。演讲快到最后的时候，有个美国学生站起来说，我现在在做怎样怎样的business，目前的情况是blablabla，问Mark有没有兴趣给他投资。。。得到的答案当然是BIG NO，呵呵。不过还是祝愿他能成功。

5. 真正成功的人是自己能把生活过的有滋有味的，热爱生活的人才会活的自信开心，才散发魅力会吸引周围的人。所以一个人的事业和生活是分不开的，要build好自己的personality，要热爱生活，要有强烈的passion，要有改变未来的勇气。

我正在努力：）

Saturday, November 17, 2012

预防癌症的１４条膳食准则

　　１９９７年９月，由美国癌症研究所的世界癌症研究基金会联合推出了一本名为“食物、营养与癌症预防”的志著，该书由８个国家的１６位著名营养学、肿瘤学专家花了３年时间集体编写而成的。本专著是对近１５年间世界各地在此领域的文献资料进行的总结晶阐述了膳食模式与癌症的关系以及膳食与癌症的发生、发展过程的关系，分析了不同部位癌症与食物和营养的关系，然后描述不同癌症的危险性与各种膳食成分（食物、营养素）及食物加工的关系，最后根据上述科学依据，提出了一套全球性的预防癌症的１４条膳食准则，其内容如下：
　　食物供应和进食及相关因素
　　１·食物供应和进食：摄取以植物性食物为主的营养充分和多种食物品种的膳食，主要选择植物来源的食物，如蔬菜、水果、豆类和加工度比较低的谷类。
　　２·保持体重：成年人群的体质数范围在２１－２３，因此，个体的体质指数［体重kg／身高2(m2)］应保持在１８.５与２５之间，避免体重过低或超重，在成年期体重的增加应限制在５kg以内。
　　３·坚持体力活动：终身坚持体力活动，如果工作时体力较少，每天应进行１小时，或进行相类似的活动量。每周还应适当安排到少有较剧烈的活动１小时。
　　食物和饮料
　　４·蔬菜和水果：全年都吃各种不同的蔬菜和水果，每天量应在４００－８００g。
　　５·其它植物性食物：每天吃各种富含淀粉或富含蛋白质的加工较低的谷类、豆类、根茎类食物６００－８００g，其总能量应占４５％－６０％，少吃精制糖。
　　６·含酒精饮料：鼓励不饮酒或不过量饮酒，如果饮酒，男性每天限饮两份，女性限饮一份（每份酒的含义为啤酒２００ml、果酒１００ml、或烈性白酒２５ml）。
　　７·肉类：如果吃肉，每日红肉（如猪肉、牛羊肉等）的摄取量应少于８０g，最好选择鱼类禽类或非家禽动物代替肉类。
　　８·总脂肪和油类：限制摄入含脂肪较多的动物性食物，摄入适量的植物油，油脂的能量占总能量的１５％－３０％以下。
　　９·盐和腌制：减少食盐的总摄取量，成人限制在每天６g以下，减少烹调用食盐和摄入腌制食品。
　　１０·贮存：易腐败的食物应妥善贮存以减少霉菌。避免吃贮存期长、受霉菌污染的食物。
　　１１·保藏：易腐败的食物，如不能及时吃掉，应冷冻或冷藏。
　　１２·添加剂及农药残留量：建立和监测对食物中食品添加剂、农药及残留量和其它化学污染物的限量，保证在规定范围内的食物添加剂和农药残留量不致产生有害作用，在发展中国家尤应注意这方面的临监测。
　　１３·烹调：不要吃烧焦的食物。避免将肉和鱼烧焦，尽量少吃火焰上直接熏烤的食物，鼓励用比较低的温度烹调食品。
　　１４·膳食补充剂：采用有利于减少癌症的危险的膳食模式，而不用膳食补充剂。如果能遵循上述膳食建议，很可能没必要用膳食补充剂，而且膳食补充剂对减少癌症危险并无帮助。

Monday, November 12, 2012

[ZZ] 自学算法之路

现在真的在自学算法，努力按照以下阶段复习中，争取做到倒背如流

第一阶段：练经典常用算法，下面的每个算法给我打上十到二十遍，同时自己精简代码，

因为太常用，所以要练到写时不用想，10-15分钟内打完，甚至关掉显示器都可以把程序打

出来.

1.最短路(Floyd、Dijstra,BellmanFord)

2.最小生成树(先写个prim,kruscal要用并查集，不好写)

3.大数（高精度）加减乘除

4.二分查找. (代码可在五行以内)

5.叉乘、判线段相交、然后写个凸包.

6.BFS、DFS,同时熟练hash表(要熟，要灵活,代码要简)

7.数学上的有：辗转相除（两行内），线段交点、多角形面积公式.

8. 调用系统的qsort, 技巧很多，慢慢掌握.

9. 任意进制间的转换

第二阶段：练习复杂一点，但也较常用的算法。

如：

1. 二分图匹配（匈牙利），最小路径覆盖

2. 网络流，最小费用流。

3. 线段树.

4. 并查集。

5. 熟悉动态规划的各个典型：LCS、最长递增子串、三角剖分、记忆化dp

6.博弈类算法。博弈树，二进制法等。

7.最大团，最大独立集。

8.判断点在多边形内。

9. 差分约束系统.

10. 双向广度搜索、A*算法，最小耗散优先.