最近想要在julia中实现 Simple Linear Iterative Clustering (SLIC) 算法对图像进行超像素分割，关于SLIC超像素分割算法，请参考SLIC Superpixels Compared to State-of-the-art Superpixel Methods。在网上搜索了一番，找到了SLIC算法的python实现代码，见laixintao仁兄SLIC算法分割超像素原理及Python实现。鉴于SLIC代码还比较复杂，就不想再去费时间自己动手写julia实现了，于是研究了一下如何通过julia调用python代码。

julia与Python的混合编程需要利用PyCall包来调用python，官方说明文档见Calling Python functions from the Julia language。(目前还没有见到有中文版本说明。)通过PyCall包，可以引入任意的python模块、调用Python函数、定义python的类、以及共享Python的数据类型。

首先需要在python中安装PyCall包，运行

Pkg.add("PyCall")

系统中要安装python，如果使用Linux系统，如笔者的是ubuntu，系统默认安装的是python3，这也是PyCall默认使用的版本。由于laixintao仁兄的代码是基于Python2写的，只能改变PyCall使用的python版本，通过以下命令实现

ENV["PYTHON"] = "/usr/bin/python2.7" # example for 2.7

(具体路径可能不同，在linux终端可以通过命令 whereis python查看所有版本的位置。)

安装并配置好PyCall后，通过pyimport命令就可以调用python内置的宏、包和函数，并且可以实现复杂数据类型之间的转换，由于本人对Python不熟悉，所以有一些也看不懂。这里我关心的只是如何调用第三方写好的python脚本。

其实实现起来也简单，参见如下说明：

If you are already familiar with Python, it perhaps is easier to use py"..." and py"""...""" which are equivalent to Python's

py"""

import numpy as np

def sinpi(x):

return np.sin(np.pi * x)

"""

py"sinpi"(1)

When creating a Julia module, it is a useful pattern to define Python functions or classes in Julia's __init__ and then use it in Julia function with py"...".

module MyModule

using PyCall

function __init__()

py"""

import numpy as np

def one(x):

return np.sin(x) ** 2 + np.cos(x) ** 2

"""

end

two(x) = py"one"(x) + py"one"(x)

end

Note that Python code in py"..." of above example is evaluated in a Python namespace dedicated to MyModule. Thus, Python function one cannot be accessed outside MyModule.

这里我要总结两点，

1)务必使用module模块中把Python脚本的代码包含进去，不然会出现不可描述的错误提示；

2)只能通过在 py""" 代码 """ 后面另写一个julia函数的方式(例如以上的two函数)调用python 函数，实现函数功能并输出结果，调用python函数时 " " 引号只能引函数名，函数参量都在引号外，不然，也会报错。

以下就是我的代码，通过调用SLIC python代码实现对图像的超像素分割，并返回每一个超像素所包含的像素点坐标。py""" """之间是调用的python源代码，后面的function是我写的调用并输出结果的函数，最后的clusters=...命令是实现对图像操作。

module MyModule

using PyCall

function __init__()

py"""

import math

from skimage import io, color

import numpy as np

from tqdm import trange

class Cluster(object):

cluster_index = 1

def __init__(self, h, w, l=0, a=0, b=0):

self.update(h, w, l, a, b)

self.pixels = []

self.no = self.cluster_index

Cluster.cluster_index += 1

def update(self, h, w, l, a, b):

self.h = h

self.w = w

self.l = l

self.a = a

self.b = b

def __str__(self):

return "{},{}:{} {} {} ".format(self.h, self.w, self.l, self.a, self.b)

def __repr__(self):

return self.__str__()

class SLICProcessor(object):

@staticmethod

def open_image(path):

rgb = io.imread(path)

lab_arr = color.rgb2lab(rgb)

return lab_arr

@staticmethod

def save_lab_image(path, lab_arr):

rgb_arr = color.lab2rgb(lab_arr)

io.imsave(path, rgb_arr)

def make_cluster(self, h, w):

return Cluster(h, w,

self.data[h][w][0],

self.data[h][w][1],

self.data[h][w][2])

def __init__(self, filename, K, M):

self.K = K

self.M = M

self.mycount = 0

self.data = self.open_image(filename)

self.image_height = self.data.shape[0]

self.image_width = self.data.shape[1]

self.N = self.image_height * self.image_width

self.S = int(math.sqrt(self.N / self.K))

self.clusters = []

self.label = {}

self.dis = np.full((self.image_height, self.image_width), np.inf)

def init_clusters(self):

h = self.S / 2

w = self.S / 2

while h < self.image_height:

while w < self.image_width:

self.clusters.append(self.make_cluster(h, w))

self.mycount += 1

w += self.S

w = self.S / 2

h += self.S

def get_gradient(self, h, w):

if w + 1 >= self.image_width:

w = self.image_width - 2

if h + 1 >= self.image_height:

h = self.image_height - 2

gradient = self.data[w + 1][h + 1][0] - self.data[w][h][0] + \

self.data[w + 1][h + 1][1] - self.data[w][h][1] + \

self.data[w + 1][h + 1][2] - self.data[w][h][2]

return gradient

def move_clusters(self):

for cluster in self.clusters:

cluster_gradient = self.get_gradient(cluster.h, cluster.w)

for dh in range(-1, 2):

for dw in range(-1, 2):

_h = cluster.h + dh

_w = cluster.w + dw

new_gradient = self.get_gradient(_h, _w)

if new_gradient < cluster_gradient:

cluster.update(_h, _w, self.data[_h][_w][0], self.data[_h][_w][1], self.data[_h][_w][2])

cluster_gradient = new_gradient

def assignment(self):

for cluster in self.clusters:

for h in range(cluster.h - 2 * self.S, cluster.h + 2 * self.S):

if h < 0 or h >= self.image_height: continue

for w in range(cluster.w - 2 * self.S, cluster.w + 2 * self.S):

if w < 0 or w >= self.image_width: continue

L, A, B = self.data[h][w]

Dc = math.sqrt(

math.pow(L - cluster.l, 2) +

math.pow(A - cluster.a, 2) +

math.pow(B - cluster.b, 2))

Ds = math.sqrt(

math.pow(h - cluster.h, 2) +

math.pow(w - cluster.w, 2))

D = math.sqrt(math.pow(Dc / self.M, 2) + math.pow(Ds / self.S, 2))

if D < self.dis[h][w]:

if (h, w) not in self.label:

self.label[(h, w)] = cluster

cluster.pixels.append((h, w))

else:

self.label[(h, w)].pixels.remove((h, w))

self.label[(h, w)] = cluster

cluster.pixels.append((h, w))

self.dis[h][w] = D

def update_cluster(self):

for cluster in self.clusters:

sum_h = sum_w = number = 0

for p in cluster.pixels:

sum_h += p[0]

sum_w += p[1]

number += 1

_h = sum_h / number

_w = sum_w / number

cluster.update(_h, _w, self.data[_h][_w][0], self.data[_h][_w][1], self.data[_h][_w][2])

def save_current_image(self, name):

image_arr = np.copy(self.data)

for cluster in self.clusters:

for p in cluster.pixels:

image_arr[p[0]][p[1]][0] = cluster.l

image_arr[p[0]][p[1]][1] = cluster.a

image_arr[p[0]][p[1]][2] = cluster.b

image_arr[cluster.h][cluster.w][0] = 0

image_arr[cluster.h][cluster.w][1] = 0

image_arr[cluster.h][cluster.w][2] = 0

self.save_lab_image(name, image_arr)

def iterate_10times(self):

self.init_clusters()

self.move_clusters()

for i in trange(10):

self.assignment()

self.update_cluster()

name = 'lenna_M{m}_K{k}_loop{loop}.png'.format(loop=i, m=self.M, k=self.K)

self.save_current_image(name)

"""

end

function slic_preprocess(self_filename::String,self_K::Int,self_M::Int)

p = py"SLICProcessor"(self_filename, self_K, self_M)

p.iterate_10times()

out = Vector{Any}(undef, p.mycount)

for i = 1 : p.mycount

out[i] = p.clusters[i].pixels

end

out

end

clusters = Main.MyModule.slic_preprocess("Lenna.png",200,40)

程序运行结果如图