first push

utils/tools.py

@@ -0,0 +1,124 @@
+#from config import cfg
+from utils.config import cfg
+from cirtorch.networks.imageretrievalnet import init_network, extract_vectors
+import torch
+from torchvision import transforms
+import cv2
+import numpy as np
+import requests
+import os, scipy, math
+import http.client
+#http.client.HTTPConnection._http_vsn = 10
+#http.client.HTTPConnection._http_vsn_str = 'HTTP/1.0'
+
+def rotate_bound(image, angle): #ratio
+    (h, w) = image.shape[:2]
+    (cX, cY) = (w // 2, h // 2)
+    M = cv2.getRotationMatrix2D((cX, cY), -angle, 1.0)
+    cos = np.abs(M[0, 0])
+    sin = np.abs(M[0, 1])
+    nW = int((h * sin) + (w * cos))
+    nH = int((h * cos) + (w * sin))
+    M[0, 2] += (nW / 2) - cX
+    M[1, 2] += (nH / 2) - cY
+    return cv2.warpAffine(image, M, (nW, nH))
+
+def createNet(): #load model
+    multiscale = '[1]'
+    print(">> Loading network:\n>>>> '{}'".format(cfg.NETWORK))
+    state = torch.load(cfg.NETWORK)
+    net_params = {}
+    net_params['architecture'] = state['meta']['architecture']
+    net_params['pooling'] = state['meta']['pooling']
+    net_params['local_whitening'] = state['meta'].get('local_whitening', False)
+    net_params['regional'] = state['meta'].get('regional', False)
+    net_params['whitening'] = state['meta'].get('whitening', False)
+    net_params['mean'] = state['meta']['mean']
+    net_params['std'] = state['meta']['std']
+    net_params['pretrained'] = False
+    net = init_network(net_params)
+    net.load_state_dict(state['state_dict'])
+    print(">>>> loaded network: ")
+    print(net.meta_repr())
+    ms = list(eval(multiscale))
+    print(">>>> Evaluating scales: {}".format(ms))
+    if torch.cuda.is_available():
+        net.cuda()
+    net.eval()
+    normalize = transforms.Normalize(
+        mean=net.meta['mean'],
+        std=net.meta['std']
+    )
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        normalize
+    ])
+    return net, transform, ms
+
+class ManagingFeature: #特征增删改查
+    def __init__(self):
+        pass
+
+    def addfeature(self, code, feature):
+        url = os.sep.join([cfg.URL, 'addImageFeatureInfo.do'])
+        json = {'code':code,
+                'featureVal':feature}
+        r = requests.post(url=url, data=json)
+        return r.text
+    
+    def deletefeature(self, code, timeStamp): #eg: "timeStamp":"2022/02/10 17:59:59"
+        url = os.sep.join([cfg.URL, 'deletImageFeatureInfo.do'])
+        json = {'code':code,
+                'timeStamp':timeStamp}
+        r = requests.get(url=url, params=json)
+        return r.json
+
+    def getfeature(self, code):
+        try:
+            url = os.sep.join([cfg.URL, 'getImageFeatureInfo.do'])
+            json = {'code': code}
+            r = requests.get(url=url, params=json)
+            data = r.json()['data']
+            return data
+        except Exception as e:
+            print('>>>>>get feature error<<<<<<')
+
+class EvaluteMap():
+    def __init__(self):
+        self.MF = ManagingFeature()
+
+    def match_feature(self, features, search_r):
+        alldict = []
+        #search_r = self.MF.getfeature(barcode)
+        for feature in features:
+            for r in search_r:
+                dist = np.linalg.norm(feature - r)
+                #alldict.append(math.pow(dist, 2))
+                alldict.append(dist)
+        meandist = scipy.mean(sorted(alldict)[0:5])
+        return meandist
+
+    def match_feature_single(self, feature, search_r):
+        alldict = []
+        for r in search_r:
+            r = np.array(r)
+            feature = np.array(feature)
+            dist = np.linalg.norm(feature-r)
+            alldict.append(dist)
+        meandist = scipy.mean(sorted(alldict)[0:2])
+        return meandist
+
+    def match_images(self, feature_dict, barcode, choose = False, mod = 'batch'):
+        if mod == 'batch':
+            result = self.match_feature(feature_dict, barcode)
+            return result
+        else:
+            result = self.match_feature_single(feature_dict, barcode)
+            return result
+
+if __name__ == '__main__':
+    pass
+#    MF = ManagingFeature()
+#    result = MF.getfeature('7613035075443')
+#    print(result)
+