Category Archives: How to Fix

Efficient palm line segmentation using u-net context fusion module

abstract

 

Many cultures in the world believe that palm reading can be used to predict a person’s future life. Palmology uses features of the hand, such as the lines of the palm, the shape of the hand, or the position of the fingertips. However, the research of palmprint detection is still relatively small, many people use the traditional image processing technology. In most real scenes, the image is usually not very good, which leads to a serious lack of performance of these methods. This paper presents an algorithm to extract main palmprint from palm image. Our method uses deep learning networks (DNNS) to improve the performance. Another challenge to this problem is the lack of training data. In order to solve this problem, the author made a data set from scratch. From this data set, the author compares the performance of the existing method with that of the author’s method. In addition, based on the structure of UNET segmentation Neural Network and the knowledge of attention mechanism, an efficient palmprint detection structure is proposed. In order to improve the segmentation accuracy, a context fusion module is proposed to capture the most important context features. The experimental results show that the F1 score of this method is the highest, about 99.42%, and the Miou is 0.584 on the same data set, which is better than other methods.

 

Innovation of the paper

 

To sum up, the main contributions of the author are summarized as follows:

DNN is proposed to solve the problem of palmprint detection. The author uses deep learning and image processing technology instead of pure traditional image processing as in other previous papers. Provide high quality data set for this problem. The data set was carefully annotated by professionals in the field. The model and context fusion module proposed by the author can achieve high accuracy even in complex palmprint images. Through this method, the author has achieved good results in Miou score.

 

Frame structure

 

The author’s image segmentation system architecture

Context fusion module integrating local and global context features

U-net has context fusion module

 

experimental result

 

The output images of some models are applied to this problem. The author’s network (UNET CFM) has achieved good results in complex palmprint input.

 

Conclusion

 

In this paper, the author uses deep learning technology to establish neural network to solve the problem of palmprint segmentation. In the author’s data set, the final Miou of the author’s model is 0.584, and the F1 score is 99.42%. The data set is manually collected and will be published for scientific purposes. Experimental results show that this method has great advantages over traditional image processing in palmprint image segmentation task. The future work of this study will be to study a more robust method to deal with the changes of complex background images; in addition, other functions of CFM can be used for further investigation.

 

Link to the paper: https://arxiv.org/pdf/2102.12127.pdf

Original text: https://mp.weixin.qq.com/s/T_ kIP8F-usNfZBzRTIk0jA

The difference between problem and observables

There is a discussion on stackoverflow: what is the difference between problems and observables?

A useful blog: angular2 observables, HTTP, and separating services and components

An article on the official website of angular: observables compared to other technologies

The difference between observable and promise:

Observables are declarative; computation does not start until subscription. Promises execute immediately on creation. This makes observables useful for defining recipes that can be run whenever you need the result.

Observable is declarative, and calculation is not triggered until subscription. This is very different from promise — promise is executed immediately after it is created.

Observables provide many values. Promises provide one. This makes observables useful for getting multiple values over time.

Observable provides multiple values, while promises can only provide a single value.

Observables differentiate between chaining and subscription. Promises only have .then() clauses. This makes observables useful for creating complex transformation recipes to be used by other part of the system, without causing the work to be executed.

Observable can be combined into complex transformation recipes with the help of rich operators in rxjs, which is convenient for reuse in application, while promise has only one then operation.

Observables subscribe() is responsible for handling errors. Promises push errors to the child promises. This makes observables useful for centralized and predictable error handling.

The crash of delete after QT removeitem in qgraphicsscene and the display residue

Problem description

In the process of using QT’s graphicsview framework to create and interact with user-defined items, you need to remove unnecessary user-defined items. However, after the user-defined items interact with the re implemented rotation and scaling, removeitem () + delete will occasionally cause the error of accessing illegal memory, and even if you only use removeitem (), there will occasionally be residual items in the view.

Solutions

Using setitemindex method of qgraphicsscene (qgraphicsscene:: Noindex);
to disable quick query of index can solve the above problem.

other

For the problem of whether to delete after using removeitem(), the official question has given a clear explanation

The ownership of item is passed on to the caller (i.e., qgraphics scene will no longer delete item when destroyed).
remove the item and all its children from the scene. Ownership of the item is passed to the caller (that is, qgraphicsscene will not delete the item when it is destroyed).

So remember to delete

[jQuery] jQuery operates on JSON strings or JSON objects

preface

Most of the time, you need to convert a JSON string to a JSON object, and then process it in a loop, or convert a JSON object to a JSON string as a parameter and pass it to the relevant interface. Next, we will introduce several conversion methods

Assume that the JSON string is

Var jsonstr = ‘[{“Id”: 1, “title”: “Zhang San”, “sex”: “male”}, {“Id”: 2, “title”: “Li Si”, “sex”: “male”}]’;

Assume that the JSON object is

Var jsonobj = [
{
“Id”: 1,
“title”: “Zhang San”,
“sex”: “male”
},
{
“Id”: 2,
“title”: “Li Si”,
“sex”: “male”
}
]

1、 Convert JSON string to JSON array object

1、eval()

var jsonObj = eval('(' + jsonStr + ')');

2、JSON.parse()

var jsonObj = JSON.parse(jsonStr);

Prev

var jsonObj = JSON.parse(jsonStr);

2、 Convert JSON object to JSON string

JSON.stringify ()

var jsonStr = JSON.stringify(jsonObj);

3、 Loop JSON object

for (var i = 0; i < jsonObj.length; i++) {

    var name= jsonObj[i].Title;

}

 

MySQL local connection Error 1130_ The solution of MySQL 1130 error report when remote connection through Navicat for MySQL

Solution of MySQL 1130 error report when remote connection through Navicat for MySQL

Navicat for MySQL 1130 error: using Navicat to connect to remote mysql, the following error is prompted. I thought it was my own firewall problem, but when it was turned off, it still couldn’t work.

I think this paragraph of English is a bit misleading and makes people feel that there is something wrong with them.

Look at the solution

ERROR 1130: Host ‘192.168.1.3’ is not allowed to connect to thisMySQL server

resolvent:

1。 Change the table method. Maybe your account is not allowed to log in from remote, only in localhost. At this time, just log in to MySQL on the computer of localhost, change the “host” item in the “user” table in the “MySQL” database, and change the name from “localhost” to “%”

mysql -u root -pvmwaremysql>usemysql;mysql>update user set host = ‘%’ where user =’root’;mysql>select host, user from user;

2. Authorization law. For example, if you want myuser to connect to the MySQL server from any host using mypassword.

Grant all privileges on *. * to identified by ‘mypassword’ with grant option; if you want to allow user myuser to connect to MySQL server from the host with IP 192.168.1.3, and use mypassword as password

GRANT ALL PRIVILEGES ON *.* TO IDENTIFIED BY’mypassword’ WITH GRANT OPTION;

Method 2

The error code is 1130, Error 1130: host xxx.xxx.xxx . XXX is not allowed to connect to this MySQL server

Authorization to users

I use the root password 123456

The preferred syntax is:

SQL code

GRANT ALL PRIVILEGES ON *.* TO ‘myuser’@’%’ IDENTIFIED BY ‘mypassword’ WITH GRANT OPTION;

Example:

Storing JSON data in session storage

Storage data:

sessionStorage.setItem("loginInfo",JSON.stringify(bdata));

Get data

var loginObj=JSON.parse(sessionStorage.getItem('loginInfo'));

In web development, session storage is often used to store data, so it is not difficult to store a single string data variable

var str = 'This is a string';
sessionStorage.setItem('param',str);

Get sessionstorage

var item = sessionStorage.getItem('param');
console.log(item);

However, sessionstorage can only store string type data, and can’t directly store array types and JSON objects. If there is a need, what should I do?It’s very simple.

First, the JSON object is passed through JSON.stringify () method is converted to a string and stored in sessionstorage

var obj = {
  "name": "Tom",
  "age": 12,
  "gender": "man"
};
sessionStorage.setItem('jsonParams',JSON.stringify(obj));

And then through JSON.parse () method to convert the string to JSON format

var data = JSON.parse(sessionStorage.getItem('jsonParams'));
console.log(data);

ioctl,unlocked_ ioctl,compat_ The difference between IOCTL

Personal blog guide home page – click here

Original text:

Follows an explanation of the patch that introduced unlocked_ioctl and compat_ioctl into 2.6.11.
The removal of the ioctl field happened a lot later, in 2.6.36.

Explanation: When ioctl was executed, it took the Big Kernel Lock (BKL), so nothing else could
execute at the same time. This is very bad on a multiprocessor machine, so there was a big effort
to get rid of the BKL. First, unlocked_ioctl was introduced. It lets each driver writer choose
what lock to use instead. This can be difficult, so there was a period of transition during which
old drivers still worked (using ioctl) but new drivers could use the improved interface (unlocked_ioctl).
Eventually all drivers were converted and ioctl could be removed.

compat_ioctl is actually unrelated, even though it was added at the same time.
Its purpose is to allow 32-bit userland programs to make ioctl calls on a 64-bit kernel.
The meaning of the last argument to ioctl depends on the driver, so there is no way to
do a driver-independent conversion

Explanation:

IOCTL: (after 2.6.36, the field is removed). The application enters the kernel and holds a giant lock/big lock/kernel lock. At the same time, only one application enters the kernel spaceunlocked_ IOCTL: 64 is a non giant lock called by the application_ IOCTL: 32 is a non giant lock called by the application

Reference:
giant lock: giant lock – big kernel lock (BKL)
fine graded locking: non giant lock – fine graded locking
what is the difference between IOCTL unlocked IOCTL and compat IOCTL

Visual studio 2017 can’t open, prompt this app can’t run on your PC

Visual studio suddenly can’t open, prompt this app can’t run on your PC

After studying for a while, we found out the reason. It’s vs2017 devenv.exe It’s broken. The size is 0 KB.

The solution is to copy one from a colleague’s computer devenv.exe Problem solving.

 

Vs2017’s devenv.exe Download: https://download.csdn.net/download/zhouyingge1104/16075855

 

When feign is called, the solution of request method ‘post’ not supported appears

background

When using springboot feign call, the following error will appear

org.springframework.web.HttpRequestMethodNotSupportedException: Request method 'POST' not supported
        at org.springframework.web.servlet.mvc.method.RequestMappingInfoHandlerMapping.handleNoMatch(RequestMappingInfoHandlerMapping.java:201)
        at org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.lookupHandlerMethod(AbstractHandlerMethodMapping.java:420)
        at org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.getHandlerInternal(AbstractHandlerMethodMapping.java:366)
        at org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.getHandlerInternal(AbstractHandlerMethodMapping.java:66)
        at org.springframework.web.servlet.handler.AbstractHandlerMapping.getHandler(AbstractHandlerMapping.java:404)
        at org.springframework.web.servlet.DispatcherServlet.getHandler(DispatcherServlet.java:1233)
        at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:1016)
        at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:943)
        at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:1006)
        at org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:909)
        at javax.servlet.http.HttpServlet.service(HttpServlet.java:660)
        at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:883)
        at javax.servlet.http.HttpServlet.service(HttpServlet.java:741)
        at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:231)
        at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
        at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:53)
        at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
        at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
        at com.github.xiaoymin.knife4j.spring.filter.ProductionSecurityFilter.doFilter(ProductionSecurityFilter.java:53)
        at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
        at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
        at com.github.xiaoymin.knife4j.spring.filter.SecurityBasicAuthFilter.doFilter(SecurityBasicAuthFilter.java:90)
        at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
        at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
        at org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:100)
        at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119)
        at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
        at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
        at org.springframework.web.filter.FormContentFilter.doFilterInternal(FormContentFilter.java:93)
        at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119)
        at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
        at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
        at org.springframework.web.filter.HiddenHttpMethodFilter.doFilterInternal(HiddenHttpMethodFilter.java:94)
        at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119)
        at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
        at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
        at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:201)
        at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119)
        at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)
        at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)
        at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:202)
        at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:96)
        at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:541)
        at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:139)
        at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:92)
        at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:74)
        at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:343)
        at org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:367)
        at org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:65)
        at org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:860)
        at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1598)
        at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49)
        at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
        at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
        at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
        at java.lang.Thread.run(Thread.java:748)

Why

It may be because there is a problem with the parameters during the query, and you need to use the specified annotation to complete the parameter transfer

Common query Bo

    public class CodeBo {
        private long start;
        private long end;

        public long getStart() {
            return start;
        }

        public void setStart(long start) {
            this.start = start;
        }

        public long getEnd() {
            return end;
        }

        public void setEnd(long end) {
            this.end = end;
        }
    }

Service provider in controller

@RestController()
@Api(tags = "Report has been Created")
@RequestMapping(value = "report", produces = MediaType.APPLICATION_JSON_VALUE)
public class ReportController {

    @GetMapping("test/test")
    List<String> listCode(@SpringQueryMap CodeBo bo){
        return new ArrayList<String>() {{
            add("AA");
            add("BB");
            add("CC");
        }};
    }
}

Feign service caller

PS: spring querymap annotation is mainly used to solve this problem

@Component
@FeignClient(value = "service")
public interface ServiceFeignClient {

    @GetMapping("test/test")
    List<String> listCode(@SpringQueryMap CodeBo bo);
}

Getoutputstream() has already been called for this response 

java.lang.IllegalStateException: getOutputStream() has already been called for this response
        at org.apache.catalina.connector.Response.getWriter(Response.java:581)
        at org.apache.catalina.connector.ResponseFacade.getWriter(ResponseFacade.java:227)
        at com.alibaba.fastjson.serializer.ASMSerializer_10_ResponseFacade.write(Unknown Source)
        at com.alibaba.fastjson.serializer.JSONSerializer.writeWithFieldName(JSONSerializer.java:333)
        at com.alibaba.fastjson.serializer.JSONSerializer.writeWithFieldName(JSONSerializer.java:311)
        at com.alibaba.fastjson.serializer.ObjectArrayCodec.write(ObjectArrayCodec.java:118)
        at com.alibaba.fastjson.serializer.JSONSerializer.write(JSONSerializer.java:285)
        at com.alibaba.fastjson.JSON.toJSONString(JSON.java:740)
        at com.alibaba.fastjson.JSON.toJSONString(JSON.java:678)
        at com.alibaba.fastjson.JSON.toJSONString(JSON.java:643)

Problem scenario: block the print request parameters in the class, and use jsonobject to convert httpservletresponse to a string.

private Object printLog(ProceedingJoinPoint joinPoint) throws Throwable {
   String ipAddress = IpAddressUtil.getIpAddress(request);
   String url = request.getRequestURL().toString();
   String params = JSON.toJSONString(joinPoint.getArgs());
   Object proceed = joinPoint.proceed();
   String result = JSON.toJSONString(proceed);
   log.info("\n-----------------------------------------------------------------------------------------------" +
          "\n<> IP:{} " +
          "\n<> url:{} " +
          "\n<> params:{} " +
          "\n<> result:{}" +
          "\n-----------------------------------------------------------------------------------------------" , ipAddress, url, params, result);
   return proceed;
}

Cause problem: the interface has two parameters, one of which is httpservletresponse

At this time, the interceptor will report an error when printing parameters.
When checking the debug, it is found that there is an error in calling getwriter after getting the object through reflection, which leads to an exception in JSON transformation
Alibaba JSON is getting the object serializer class asmserializer_ 1_ Resposefacade called ResponseFacade.getWriter （）
write javaBean error, fastjson version 1.2.58, class com.sun.proxy .$Proxy128, method : getWriter

Error usage code:

HttpServletResponse response;
JSON.toJSONString (response);
to sum up, jsonobject is unable to serialize httpservletresponse, thus reporting the above exception