opencv人脸五官切割 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
# coding: utf-8
import cv2
import dlib
import numpy
import sys

PREDICTOR_PATH = "./shape_predictor_68_face_landmarks.dat"
SCALE_FACTOR = 1
FEATURE_AMOUNT = 11

FACE_POINTS = list(range(17, 68))
MOUTH_POINTS = list(range(48, 68))
RIGHT_BROW_POINTS = list(range(17, 22))
LEFT_BROW_POINTS = list(range(22, 27))
RIGHT_EYE_POINTS = list(range(36, 42))
LEFT_EYE_POINTS = list(range(42, 48))
NOSE_POINTS = list(range(27, 36))
JAW_POINTS = list(range(0, 17))

# Points used to line up the images
ALIGN_POINTS = (LEFT_BROW_POINTS + RIGHT_EYE_POINTS + LEFT_EYE_POINTS +
                RIGHT_BROW_POINTS + NOSE_POINTS + MOUTH_POINTS)

# Points from the second image to overlay on the first. The convex hull of
# each element will be overlaid
OVERLAY_POINTS = [
    LEFT_EYE_POINTS + RIGHT_EYE_POINTS + LEFT_BROW_POINTS
    + RIGHT_BROW_POINTS,
    NOSE_POINTS + MOUTH_POINTS,
]

# Amount of blur to use during color correction, as a fraction of the
# pupillary distance
COLOUR_CORRECT_BLUR_FRAC = 0.05

detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(PREDICTOR_PATH)


class TooManyFaces(Exception):
    pass


class NoFaces(Exception):
    pass


## input: an image in the form of a numpy array
## return: a 68 * 2 element matrix, each row corresponding with
## the x, y coordintes of a pariticular feature point in the input image
def get_landmarks(im):
    rects = detector(im, 1)

    if len(rects) > 1:
        raise TooManyFaces
    if len(rects) == 0:
        raise NoFaces

    # the feature extractor (predictor) requires a rough bounding box as input
    # to the algorithm. This is provided by a traditional face detector (
    # detector) which returns a list of rectangles, each of which corresponding
    # a face in the image
    return numpy.int32(numpy.matrix([[p.x, p.y] for p in predictor(im, rects[0]).parts()]))


def annote_landmarks(im, landmarks):
    im = im.copy()
    for idx, point in enumerate(landmarks):
        pos = (point[0, 0], point[0, 1])
        cv2.putText(im, str(idx), pos,
                    fontFace=cv2.FONT_HERSHEY_SCRIPT_SIMPLEX,
                    fontScale=0.4,
                    color=(0, 0, 255))
        cv2.circle(im, pos, 3, color=(0, 255, 255))
    return im


def read_im_and_landmarks(im):
    # im = cv2.imread(fname, cv2.IMREAD_COLOR)
    im = cv2.resize(im, (im.shape[1] * SCALE_FACTOR,
                         im.shape[0] * SCALE_FACTOR))
    s = get_landmarks(im)

    return im, s


def transformation_from_points(points1, points2):
    """
    Return an affine transformation [s * R | T] such that:

        sum || s*R*p1,i + T - p2,i||^2

    is minimized.
    """

    # Solve the procrustes problem by substracting centroids, scaling by the
    # standard deviation, and then using the SVD to calculate the rotation. See
    # the following for more details:
    # https://en.wikipedia.org/wiki/Orthogonal_Procrustes_problem

    points1 = points1.astype(numpy.float64)
    points2 = points2.astype(numpy.float64)

    c1 = numpy.mean(points1, axis=0)
    c2 = numpy.mean(points2, axis=0)
    points1 -= c1
    points2 -= c2

    s1 = numpy.std(points1)
    s2 = numpy.std(points2)
    points1 /= s1
    points2 /= s2

    U, S, Vt = numpy.linalg.svd(points1.T * points2)

    # The R we seek is in fact the transpose of the one given by U * Vt. This
    # is because the above formulation assumes the matrix goes on the right
    # (with row vectors) where as our solution requires the matrix to be on the
    # left (with column vectors).
    R = (U * Vt).T

    return numpy.vstack([numpy.hstack(((s2 / s1) * R,
                                       c2.T - (s2 / s1) * R * c1.T)),
                         numpy.matrix([0., 0., 1.])])


def draw_convex_hull(im, points, color):
    # print(points)
    points = cv2.convexHull(points, returnPoints=True)
    #print(points)
    cv2.fillConvexPoly(im, points, color=color)


def get_face_mask(im, landmarks):
    im = numpy.zeros(im.shape[:2], dtype=numpy.float64)

    for group in OVERLAY_POINTS:
        # print(landmarks[group])
        draw_convex_hull(im,
                         landmarks[group],
                         color=1)

    im = numpy.array([im, im, im]).transpose((1, 2, 0))

    im = (cv2.GaussianBlur(im, (FEATURE_AMOUNT, FEATURE_AMOUNT), 0) > 0) * 1.0
    im = cv2.GaussianBlur(im, (FEATURE_AMOUNT, FEATURE_AMOUNT), 0)

    return im


def warp_im(im, M, dshape):
    output_im = numpy.zeros(dshape, dtype=im.dtype)
    cv2.warpAffine(im,
                   M[:2],
                   (dshape[1], dshape[0]),
                   dst=output_im,
                   borderMode=cv2.BORDER_TRANSPARENT,
                   flags=cv2.WARP_INVERSE_MAP)
    return output_im


def get_mask(im, landmarks, color, mask=None):
    if mask is None:
        mask = numpy.zeros(im.shape[:2], dtype=numpy.float64)
    landmarks = cv2.convexHull(landmarks, returnPoints=True)
    cv2.fillConvexPoly(mask, landmarks, color=color)
    return mask


def get_img_from_mask(im, mask, color):
    """
        获取mask图，背景颜色为黑色
    :param im:
    :param mask:
    :param color:
    :return:
    """
    img = im.copy()
    # l = list()
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            if mask[i, j] != color:
                img[i, j] = [0, 0, 0]
            # else:
            #     l.append(img[i, j])
    # face_array = numpy.array(l)
    # print(face_array.shape)
    # print(numpy.mean(face_array, axis=0))

    return img

params = cv2.SimpleBlobDetector_Params()
params.minArea=8
params.maxArea=1000
blob = cv2.SimpleBlobDetector_create(params)

img = cv2.imread("./face_data/doudou.png", cv2.IMREAD_COLOR)
im1, landmarks1 = read_im_and_landmarks(img)
#face_mask = get_face_mask(im1, landmarks1)

mask = numpy.zeros(img.shape[:2], dtype=numpy.float64)
mask = get_mask(im1, landmarks1[LEFT_EYE_POINTS], color=1, mask=mask)
mask = get_mask(im1, landmarks1[RIGHT_EYE_POINTS], color=1, mask=mask)
mask = get_mask(im1, landmarks1[MOUTH_POINTS], color=1, mask=mask)
mask = get_mask(im1, landmarks1[LEFT_BROW_POINTS], color=1, mask=mask)
mask = get_mask(im1, landmarks1[RIGHT_BROW_POINTS], color=1, mask=mask)
mask = get_mask(im1, landmarks1[NOSE_POINTS], color=1, mask=mask)

blur_mask = (cv2.GaussianBlur(mask, (FEATURE_AMOUNT, FEATURE_AMOUNT), 0) > 0) * 1.0
blur_mask = (cv2.GaussianBlur(blur_mask, (FEATURE_AMOUNT, FEATURE_AMOUNT), 0) > 0.3) * 1.0

total_face_mask = get_mask(im1, landmarks1, color=1)

# 没有五官的面部
total_face_without_features = numpy.logical_xor(total_face_mask, blur_mask)

without_features_img = get_img_from_mask(im1, total_face_without_features, color=1)
mask = get_img_from_mask(im1, blur_mask, color=1)

keypoints = blob.detect(mask)
print(keypoints)
im_with_keypoints = cv2.drawKeypoints(mask, keypoints, numpy.array([]), (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
cv2.imshow("total_face_without_features", numpy.hstack((im1, mask, without_features_img)))

cv2.waitKey(0)
cv2.destroyAllWindows()

upload successful

展开全文 >>

Remove Duplicates from Sorted List II

82. Remove Duplicates from Sorted List II

Difficulty: Medium

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

For example,
Given 1->2->3->3->4->4->5, return 1->2->5.
Given 1->1->1->2->3, return 2->3.

Solution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode nHead = new ListNode(Integer.MAX_VALUE);
        
        ListNode newList = nHead;
        boolean repeat = false;
        for(ListNode cur = head; cur!=null; cur = cur.next){
        	// 遍历重复的
            for(;cur.next!=null && cur.val==cur.next.val;){
                cur = cur.next;
                repeat = true;
            }
            // 跳过重复的最后一个
            if(repeat){
                repeat = false;
                continue;
            }else{
                newList.next = cur;
                newList = cur;
            }
        }
        newList.next = null;
        return nHead.next;
    }
}

展开全文 >>

Partition List

86. Partition List

Difficulty: Medium

Given a linked list and a value _x_, partition it such that all nodes less than _x_ come before nodes greater than or equal to _x_.

You should preserve the original relative order of the nodes in each of the two partitions.

For example,
Given 1->4->3->2->5->2 and _x_ = 3,
return 1->2->2->4->3->5.

Solution

用两个链表分别存储，最后合并

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode l = new ListNode(0);
        ListNode s = new ListNode(0);
        
        // 记住开始位置
        ListNode large = l;
        ListNode small = s;
        
        for(ListNode cur = head; cur!=null;cur = cur.next){
            if(cur.val >=x){
                large.next = cur;
                large = cur;
                //System.out.println("large"+cur.val);
            }else{
                small.next = cur;
                small = cur;
                //System.out.println("small"+cur.val);
            }
        }
        large.next = null; // 不加这句话，next是随机初始化的
        // 合并大小链表
        small.next = l.next;
        return s.next;
    }
}}
}

展开全文 >>

Longest Consecutive Sequence

128. Longest Consecutive Sequence

Difficulty: Hard

Given an unsorted array of integers, find the length of the longest consecutive elements sequence.

For example,
Given [100, 4, 200, 1, 3, 2],
The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.

Your algorithm should run in O(_n_) complexity.

Solution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
       public int longestConsecutive(int[] nums) {
        Map<Integer,Integer> ranges = new HashMap<>();
        int max = 0;
        for (int num : nums) {
            if (ranges.containsKey(num)) continue;
            
            int left = ranges.getOrDefault(num - 1, 0);
            int right = ranges.getOrDefault(num + 1, 0);
            int sum = left + right + 1;
            max = Math.max(max, sum);
            // 直接更新边界,因为下一次碰到的不可能在内部
            if (left > 0) ranges.put(num - left, sum); 
            if (right > 0) ranges.put(num + right, sum);
            ranges.put(num, sum); 
        }
        return max;
    }
}

展开全文 >>

Remove Duplicates from Sorted Array II

80. Remove Duplicates from Sorted Array II

Difficulty: Medium

Follow up for “Remove Duplicates”:
What if duplicates are allowed at most twice?

For example,
Given sorted array nums = [1,1,1,2,2,3],

Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3. It doesn’t matter what you leave beyond the new length.

Solution

因为是有序的，所以出现不递增的就是重复的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums.length<=2)return nums.length;
        int index = 2;
        for(int i=2;i<nums.length;i++){
            
            if(nums[i]>nums[index-2]){
                nums[index] = nums[i];
                index++;
            }
        }
        return index;
    }
}

展开全文 >>

Jump Game

55. Jump Game

Difficulty: Medium

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Determine if you are able to reach the last index.

For example:
A = [2,3,1,1,4], return true.

A = [3,2,1,0,4], return false.

Solution

使用有向图遍历，超时

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Solution {
    public boolean canJump(int[] nums) {
        if(null == nums)return false;
        int len = nums.length;
        if(len==0)return false;
        if(len==1)return true;
        
        List<List<Integer>> graph = new ArrayList<>(len);
        
        // 初始化有向图        
        for(int i=0;i<len-1;i++){
            List<Integer> list = new ArrayList<>();
            graph.add(list);
            int n = nums[i];
            for(int j=1;j<=n&&j<=len-1;j++){
                list.add(i+j);
            }
        }
        
        int[] visited = new int[len];
        LinkedList<Integer> q = new LinkedList<>();
        
        q.add(0);
        while(!q.isEmpty()){
            int pos = q.getFirst();
            q.removeFirst();
            if(visited[pos]==1)continue;
            List<Integer> list = graph.get(pos);
            //System.out.println(list);
            System.out.println(pos);
            for(int n:list){
                //System.out.print(" "+n);
                if(n==len-1)return true;
                q.addLast(n);
            }
            
            visited[pos]=1;
            
        }
        return false;
    }
}

直接拓展右边界

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution {
    public boolean canJump(int[] nums) {
        if(null == nums)return false;
        int len = nums.length;
        if(len==0)return false;
        if(len==1)return true;
        
        int maxR = 0;    
        for(int i=0;i<len-1;i++){
            
            if(i<=maxR){
                int r = i+nums[i];
                if(maxR<r)maxR = r;
                if(maxR>=len-1)return true;
            }else{
                return false;
            }
        }
        
        
        return false;
    }
}

展开全文 >>

Lowest Common Ancestor of a Binary Tree

236. Lowest Common Ancestor of a Binary Tree

Difficulty: Medium

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.

According to the : “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”

1
2
3
4
5
6
7
     _______3______
    /              \
 ___5__          ___1__
/      \        /      \
6      _2       0       8
      /  \
      7   4

For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.

Solution

递归解法，这里都是假定p和q是在树中存在的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(null==root || root==p || root==q)return root;
        
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        
        if(left!=null && right!=null)return root;
        if(left!=null)return left;
        return right;
    }
}

tarjen 算法

展开全文 >>

Lowest Common Ancestor of a Binary Search Tree

235. Lowest Common Ancestor of a Binary Search Tree

Difficulty: Easy

Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.

According to the : “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”

1
2
3
4
5
6
7
     _______6______
    /              \
 ___2__          ___8__
/      \        /      \
0      _4       7       9
      /  \
      3   5

For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

Solution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        while (null!=root && (root.val - p.val) * (root.val - q.val) > 0)
            root = p.val < root.val ? root.left : root.right;
        return root;
    }
}

展开全文 >>

网易有道2017内推编程题

洗牌

洗牌在生活中十分常见，现在需要写一个程序模拟洗牌的过程。 现在需要洗2n张牌，从上到下依次是第1张，第2张，第3张一直到第2n张。首先，我们把这2n张牌分成两堆，左手拿着第1张到第n张（上半堆），右手拿着第n+1张到第2n张（下半堆）。接着就开始洗牌的过程，先放下右手的最后一张牌，再放下左手的最后一张牌，接着放下右手的倒数第二张牌，再放下左手的倒数第二张牌，直到最后放下左手的第一张牌。接着把牌合并起来就可以了。 例如有6张牌，最开始牌的序列是1,2,3,4,5,6。首先分成两组，左手拿着1,2,3；右手拿着4,5,6。在洗牌过程中按顺序放下了6,3,5,2,4,1。把这六张牌再次合成一组牌之后，我们按照从上往下的顺序看这组牌，就变成了序列1,4,2,5,3,6。 现在给出一个原始牌组，请输出这副牌洗牌k次之后从上往下的序列。

输入描述:

第一行一个数T(T ≤ 100)，表示数据组数。对于每组数据，第一行两个数n,k(1 ≤ n,k ≤ 100)，接下来一行有2n个数a1,a2,…,a2n(1 ≤ ai ≤ 1000000000)。表示原始牌组从上到下的序列。

输出描述:

对于每组数据，输出一行，最终的序列。数字之间用空格隔开，不要在行末输出多余的空格。

输入例子1:

3 3 1 1 2 3 4 5 6 3 2 1 2 3 4 5 6 2 2 1 1 1 1

输出例子1:

1 4 2 5 3 6 1 5 4 3 2 6 1 1 1 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.util.*;

public class Main{

    public static void main(String[] args){
        Scanner scn = new Scanner(System.in);
        int T = scn.nextInt();
        while(T-->0){
            int n,k;
            n = scn.nextInt();
            k = scn.nextInt();
            int[] a= new int[n*2];
            int[] temp = new int[n*2];
            int[] t = null;

            for(int i=0;i<n*2;i++){
                a[i] = scn.nextInt();
            }
            for(int i=0;i<k;i++){
                for(int j=0;j<2*n;j++){
                    if(j<=n-1)
                        temp[j*2] = a[j];
                    else
                        temp[(j-n)*2+1] = a[j];
                }
                t = a;
                a = temp;
                temp = t;
                
            }
            for(int i=0;i<2*n-1;i++){
                System.out.print(a[i]+" ");
            }
            if(n>=1){
                System.out.println(a[2*n-1]);
            }
        }
    }
}
  1. 一开始想得太复杂了，想先找出规律（是有规律的），浪费了太多时间
  2. 1
    2
    3
    4
    if(j<=n-1)
    	temp[j*2] = a[j];
    else
    	temp[(j-n)*2+1] = a[j];

一开始写反了

构造队列

小明同学把1到n这n个数字按照一定的顺序放入了一个队列Q中。现在他对队列Q执行了如下程序：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
while(!Q.empty())              //队列不空，执行循环

{

    int x=Q.front();            //取出当前队头的值x

    Q.pop();                 //弹出当前队头

    Q.push(x);               //把x放入队尾

    x = Q.front();              //取出这时候队头的值

    printf("%d\n",x);          //输出x

    Q.pop();                 //弹出这时候的队头

}

做取出队头的值操作的时候，并不弹出当前队头。
小明同学发现，这段程序恰好按顺序输出了1,2,3,…,n。现在小明想让你构造出原始的队列，你能做到吗？

输入描述:

第一行一个整数T（T ≤ 100）表示数据组数，每组数据输入一个数n（1 ≤ n ≤ 100000），输入的所有n之和不超过200000。

输出描述:

对于每组数据，输出一行，表示原始的队列。数字之间用一个空格隔开，不要在行末输出多余的空格.

输入例子1:

4
1
2
3
10

输出例子1:

1
2 1
2 1 3
8 1 6 2 10 3 7 4 9 5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner scn = new Scanner(System.in);
        int T;
        T = scn.nextInt();
        while(T-->0){
            int n = scn.nextInt();
            LinkedList<Integer> res = new LinkedList<Integer>();
            for(int i=n;i>0;i--){ 
                int x = i;
                res.addFirst(x);
                x = res.removeLast();
                res.addFirst(x);
            }
            for(int i=0;i<res.size()-1;i++){
                System.out.print(res.get(i)+" ");
            }
            if(res.size()>0)System.out.println(res.get(res.size()-1));
        }
    }
}

只能过80%,原因是因为get(i)方法每次都要查询遍历，会把时间复杂度变为O(n^2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner scn = new Scanner(System.in);
        int T;
        T = scn.nextInt();
        while(T-->0){
            int n = scn.nextInt();
            LinkedList<Integer> res = new LinkedList<Integer>();
            for(int i=n;i>0;i--){ 
                int x = i;
                res.addFirst(x);
                x = res.removeLast();
                res.addFirst(x);
            }
            for(int i=0;i<n-1;i++){
                System.out.print(res.removeFirst()+" ");
            }
            if(res.size()>0)System.out.println(res.removeFirst());
        }
    }
}

展开全文 >>

nginx负载均衡

目前要在两台机器上做负载均衡，按网上的教程写的，一般都是两台机器按一样的配置，或者就是配好后只访问一台，这里总结一下。

以机器1的9000为负载均衡端口，其他机器的8000端口访问本机

  • 机器1:172.16.201.1
  • 机器2:172.16.201.2

172.16.201.1配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
upstream myservers{
		server 127.0.0.1:8000 weight=2;
    	server 127.0.0.2:8000 weight=1;
    		
}
server { 
    listen 8000;
    server_name 127.0.0.1; 
    
    location / { 
        这里不要写proxy_pass，以免出现互相转发死循环，转发只发生在9000端口
    }
}
server { 
    listen 9000; # 负载均衡转发端口
    server_name 127.0.0.1; 
    
    location / { 
        proxy_pass http://myservers;
    }
}

172.16.201.2配置

1
2
3
4
5
6
7
8
server { 
    listen 8000;
    server_name 127.0.0.1; 
    
    location / { 
        这里不要写proxy_pass，以免出现互相转发死循环，转发只发生在9000端口
    }
}

这样访问 172.16.201.1:9000就可以按访问频率分发到两个机器上了

最好使用firefox，不要用chrome,不要打开开发者工具

upload successful

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家