Image processing method and device, electronic equipment and storage medium

Abstract

The invention provides an image processing method and device, electronic equipment and a storage medium. The image processing method comprises the following steps: acquiring a four-view image of a target area; the pixel value and the pixel weight value of the four-view image are loaded into a neon register through a first neon instruction; processing the pixel weight value and the pixel value in the neon register through a neon calculation instruction to obtain an aerial view pixel value of the target area; storing the aerial view pixel value into a memory through a neon storage instruction; loading the aerial view pixel value in the memory through a first neon loading instruction; performing fusion processing on the aerial view pixel value through a second neon instruction to obtain a fused aerial view pixel value; and the fused aerial view pixel value is loaded into the memory through a second neon loading instruction. The image processing method can improve the operation efficiency of overlook stitching, and is suitable for scenes with high efficiency requirements.

Description

Technical Field

[0001] This disclosure pertains to the field of image processing, specifically relating to image processing methods and apparatuses, electronic devices, and storage media. Background Technology

[0002] Currently, in the field of automated parking, parking space detection needs to be performed in a top-down view, making top-down stitching algorithms indispensable. High overall algorithm efficiency is required for parking, but traditional top-down stitching algorithms are inefficient, impacting the overall algorithm's performance. Therefore, current image processing methods using top-down stitching suffer from low efficiency. Summary of the Invention

[0003] This disclosure provides an image processing method and apparatus, electronic device, and storage medium to address the problem of low operating efficiency in existing image processing methods for top-view stitching.

[0004] In a first aspect, this disclosure provides an image processing method. The image processing method includes: acquiring four-view images of a target region, the four-view images including a plurality of front view images, a plurality of rear view images, a plurality of left view images, and a plurality of right view images; loading pixel values ​​and pixel weight values ​​of the four-view images into a neon register using a first neon instruction; processing the pixel weight values ​​and pixel values ​​in the neon register using a neon calculation instruction to obtain bird's-eye view pixel values ​​of the target region; saving the bird's-eye view pixel values ​​into memory using a neon storage instruction; loading the bird's-eye view pixel values ​​from memory using a first neon load instruction; performing a fusion process on the bird's-eye view pixel values ​​using a second neon instruction to obtain fused bird's-eye view pixel values; and loading the fused bird's-eye view pixel values ​​into memory using a second neon load instruction.

[0005] In one embodiment of this disclosure, the method for loading the pixel values ​​and pixel weight values ​​of the four-view image into the neon register using a first neon instruction includes: loading the pixel values ​​of the four-view image into the neon register using a third neon load instruction; loading the four-view index into the neon register using the third neon load instruction; querying the neon register using a neon lookup table instruction based on the index in the neon register to obtain the pixel value corresponding to the index in the neon register; saving the pixel values ​​in the neon register into memory using a neon store instruction; loading the pixel weight values ​​of the four-view image into the neon register using a fourth neon load instruction; and loading the pixel values ​​in memory into the neon register using a fourth neon load instruction.

[0006] In one embodiment of this disclosure, the method of loading the four-view index into the neon register by the third neon load instruction includes: the four-view index includes a Y index, a U index, and a V index; loading the Y index into the neon register by the third neon load instruction; loading the U index into the neon register by the third neon load instruction; and loading the V index into the neon register by the third neon load instruction.

[0007] In one embodiment of this disclosure, the method for obtaining pixel values ​​in the neon register by querying the neon register using a neon lookup table instruction based on an index in the neon register includes: querying the neon register using a neon lookup table instruction based on a Y index in the neon register to obtain Y pixel values ​​in the neon register; querying the neon register using a neon lookup table instruction based on a U index in the neon register to obtain U pixel values ​​in the neon register; and querying the neon register using a neon lookup table instruction based on a V index in the neon register to obtain V pixel values ​​in the neon register.

[0008] In one embodiment of this disclosure, a method for obtaining the bird's-eye view pixel values ​​of the target region by processing the pixel weight values ​​and pixel values ​​in the neon register using neon calculation instructions includes: the pixel weight values ​​include Y pixel weight values, U pixel weight values, and V pixel weight values; processing the Y pixel weight values ​​and Y pixel values ​​in the neon register using the neon calculation instructions to obtain the Y pixel values ​​of the bird's-eye view of the target region; processing the U pixel weight values ​​and U pixel values ​​in the neon register using the neon calculation instructions to obtain the U pixel values ​​of the bird's-eye view of the target region; and processing the V pixel weight values ​​and V pixel values ​​in the neon register using the neon calculation instructions to obtain the V pixel values ​​of the bird's-eye view of the target region.

[0009] In one embodiment of this disclosure, the method for fusing the bird's-eye view pixel values ​​using a second neon instruction to obtain fused bird's-eye view pixel values ​​includes: the bird's-eye view pixel values ​​include front view bird's-eye view pixel values, rear view bird's-eye view pixel values, left view bird's-eye view pixel values, and right view bird's-eye view pixel values; fusing the front view bird's-eye view pixel values ​​and left view bird's-eye view pixel values ​​using a second neon instruction to obtain the fused left front portion bird's-eye view pixel values; fusing the front view bird's-eye view pixel values ​​and right view bird's-eye view pixel values ​​using a second neon instruction to obtain the fused right front portion bird's-eye view pixel values; fusing the rear view bird's-eye view pixel values ​​and left view bird's-eye view pixel values ​​using a second neon instruction to obtain the fused left rear portion bird's-eye view pixel values; and fusing the rear view bird's-eye view pixel values ​​and right view bird's-eye view pixel values ​​using a second neon instruction to obtain the fused right rear portion bird's-eye view pixel values.

[0010] In one embodiment of this disclosure, the method for fusing the pixel values ​​of the front view bird's-eye view and the left view bird's-eye view using the second neon instruction to obtain the fused left front portion bird's-eye view pixel values ​​includes: loading the Y pixel values ​​of the front view bird's-eye view into the neon register using a fifth neon loading instruction; loading the Y pixel values ​​of the left view bird's-eye view into the neon register using the fifth neon loading instruction; fusing the Y pixel values ​​of the front view bird's-eye view and the Y pixel values ​​of the left view bird's-eye view in the neon register using a neon fusion instruction to obtain the fused left front portion bird's-eye view Y pixel values; and loading the U pixel values ​​of the front view bird's-eye view into the neon register using the fifth neon loading instruction. The fifth neon loading instruction loads the left-view bird's-eye view U pixel value into the neon register; the neon fusion instruction merges the front-view bird's-eye view U pixel value and the left-view bird's-eye view U pixel value in the neon register to obtain the merged front-left bird's-eye view U pixel value; the fifth neon loading instruction loads the front-view bird's-eye view V pixel value into the neon register; the fifth neon loading instruction loads the left-view bird's-eye view V pixel value into the neon register; the neon fusion instruction merges the front-view bird's-eye view V pixel value and the left-view bird's-eye view V pixel value in the neon register to obtain the merged front-left bird's-eye view V pixel value.

[0011] Secondly, embodiments of this disclosure provide an image processing apparatus. The image processing apparatus includes: an image acquisition module for acquiring four-view images of a target region, the four-view images including a plurality of front view images, a plurality of rear view images, a plurality of left view images, and a plurality of right view images; a first pixel loading module for loading pixel values ​​and pixel weight values ​​of the four-view images into a neon register using a first neon instruction; a pixel processing module for processing the pixel weight values ​​and pixel values ​​in the neon register using a neon calculation instruction to obtain bird's-eye view pixel values ​​of the target region; a first pixel storage module for storing the bird's-eye view pixel values ​​into memory using a neon storage instruction; a second pixel loading module for loading the bird's-eye view pixel values ​​from memory using a first neon loading instruction; a pixel fusion module for performing fusion processing on the bird's-eye view pixel values ​​using a second neon instruction to obtain fused bird's-eye view pixel values; and a second pixel storage module for storing the fused bird's-eye view pixel values ​​into memory using a second neon loading instruction.

[0012] Thirdly, embodiments of this disclosure also provide a computer-readable storage medium having a computer program stored thereon. When executed by a processor, the computer program implements the image processing method described in any of the first aspects.

[0013] Fourthly, embodiments of this disclosure also provide an electronic device. The electronic device includes: a memory storing a computer program; and a processor communicatively connected to the memory, which, when the computer program is invoked, executes the image processing method described in any of the first aspects.

[0014] According to the image processing method, apparatus, electronic device, and storage medium disclosed herein, by performing image pixel fusion processing based on neon instructions to obtain the fused bird's-eye view pixel values, the operating efficiency of top-down stitching can be improved, making it suitable for scenarios with high efficiency requirements. Attached Figure Description

[0015] Figure 1 The diagram shows a schematic representation of an existing image processing method disclosed herein.

[0016] Figure 2 The flowchart shown is an embodiment of the image processing method of this disclosure.

[0017] Figure 3 The flowchart shown is an implementation method of loading the pixel values ​​and pixel weight values ​​of the four-view image into the neon register through the first neon instruction in an embodiment of this disclosure.

[0018] Figure 4The flowchart shown is an implementation method of loading the four-view index into the neon register by the third neon load instruction according to an embodiment of this disclosure.

[0019] Figure 5 This is a flowchart illustrating a method for retrieving pixel values ​​from the neon register by querying the neon register using a neon lookup table instruction based on an index in the neon register, according to an embodiment of this disclosure.

[0020] Figure 6 The flowchart shown is a method for processing pixel weight values ​​and pixel values ​​in the neon register using neon calculation instructions to obtain the bird's-eye view pixel values ​​of the target area, according to an embodiment of this disclosure.

[0021] Figure 7 The flowchart shown is a method for implementing a method of fusing the pixel values ​​of the bird's-eye view using a second neon instruction to obtain the fused pixel values ​​of the bird's-eye view, according to an embodiment of this disclosure.

[0022] Figure 8 The flowchart shown is a method for implementing the fusion of the front view bird's-eye view pixel values ​​and the left view bird's-eye view pixel values ​​by using the second neon instruction in an embodiment of this disclosure to obtain the fused left front part bird's-eye view pixel values.

[0023] Figure 9 The diagram shown is a schematic representation of the image processing apparatus according to an embodiment of this disclosure.

[0024] Figure 10 The diagram shown is a structural schematic of an electronic device according to an embodiment of this disclosure. Detailed Implementation

[0025] The following specific examples illustrate the implementation of this disclosure. Those skilled in the art can easily understand other advantages and effects of this disclosure from the content disclosed in this specification. This disclosure can also be implemented or applied through other different specific embodiments, and various details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of this disclosure. It should be noted that, unless otherwise specified, the following embodiments and features in the embodiments can be combined with each other.

[0026] It should be noted that the illustrations provided in the following embodiments are only schematic representations of the basic concept of this disclosure. Therefore, the illustrations only show the components related to this disclosure and are not drawn according to the number, shape and size of the components in actual implementation. In actual implementation, the form, quantity and proportion of each component can be arbitrarily changed, and the layout of the components may also be more complex.

[0027] The technical solutions of the present disclosure will be described in detail below with reference to the accompanying drawings.

[0028] The image processing method provided in this disclosure can run on mobile terminals, computer terminals, and similar devices. Taking the mobile terminal as an example, Figure 1 This is a hardware structure block diagram of the mobile terminal, such as... Figure 1 As shown, a mobile terminal may include a processor and a memory, wherein the processor may be a central processing unit and the memory is used to store data. Figure 1 The mobile terminal in the example is for illustrative purposes only and is not intended to limit the specific structure of the mobile terminal.

[0029] In some embodiments, the mobile terminal may further include: a communication transmission device and an input / output device.

[0030] In some embodiments, the memory may be used to store computer programs, such as application software programs and modules. The memory may include high-speed random access memory (RAM) and non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some instances, the memory may further include memory remotely located relative to the processor, which can be connected to the mobile terminal via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks (LANs), mobile communication networks, and combinations thereof.

[0031] In some embodiments, the communication transmission device can be used to receive or send data via a network, which may include a wireless network provided by the mobile terminal's communication provider. The communication transmission device may include a NIC (Network Interface Controller), which can be connected to other network devices via a base station to communicate with the Internet.

[0032] The principles and implementation methods of the image processing methods, apparatus, electronic devices, and storage media disclosed herein will be described in detail below, so that those skilled in the art can understand the image processing methods, apparatus, electronic devices, and storage media disclosed herein without creative effort.

[0033] Figure 2 This is a flowchart illustrating an image processing method according to an embodiment of the present disclosure. Figure 2 As shown, the image processing method provided in this embodiment can be executed by a processor, and the method includes the following steps S11 to S17.

[0034] Step S11: Obtain four-view images of the target area, including several front view images, several rear view images, several left view images, and several right view images.

[0035] Optionally, the number of the front view image, the rear view image, the left view image, and the right view image are the same.

[0036] Step S12: Load the pixel values ​​and pixel weight values ​​of the four-view image into the neon register using the first neon instruction.

[0037] Optionally, the first neon instruction may refer to the first neon instruction set. Neon is a 128-bit SIMD (Single Instruction Multiple Data) extended instruction set that supports operations including addition, multiplication, comparison, shift, absolute value, maximum and minimum value operations, save and load instructions, etc.

[0038] Step S13: Process the pixel weight value and pixel value in the neon register using neon calculation instructions to obtain the bird's-eye view pixel value of the target area.

[0039] Optionally, the neon calculation instruction may refer to the vmlal_u8 instruction, and the pixel weight value in the neon register and the pixel value can be the inputs to this instruction. The vmlal_u8 instruction is an unsigned 8-bit integer multiply-accumulate instruction in the neon instruction set, used to perform multiplication and accumulation operations.

[0040] Optionally, the method of processing the pixel weight value and pixel value in the neon register through neon calculation instructions to obtain the bird's-eye view pixel value of the target area further includes: shifting the bird's-eye view pixel value through a neon shift instruction to obtain the shifted bird's-eye view pixel value. The neon shift instruction can be a vshrn_n_u16 instruction, the input of which can be the bird's-eye view pixel value and the number of shift bits, which can be 8. The vshrn_n_u16 instruction is a narrow right shift instruction in the neon instruction set, used to right shift a 16-bit unsigned integer vector by a specified number of bits and then truncate the lower 8 bits.

[0041] Step S14: Save the bird's-eye view pixel values ​​to memory using the neon storage instruction.

[0042] Optionally, the neon storage instruction may refer to the vst1_u8 instruction. The vst1_u8 instruction is a neon instruction set used to store an 8-bit unsigned integer vector into memory.

[0043] Step S15: Load the bird's-eye view pixel values ​​in the memory into the neon register using the first neon load instruction.

[0044] Optionally, the first neon load instruction may refer to the vld1q_u8 instruction. The vld1q_u8 instruction loads a 128-bit unsigned 8-bit integer from memory and stores it in a neon register.

[0045] Step S16: The bird's-eye view pixel values ​​are fused using the second neon instruction to obtain the fused bird's-eye view pixel values.

[0046] Step S17: The fused bird's-eye view pixel values ​​are loaded into the memory using the second neon loading instruction.

[0047] Optionally, the second neon load instruction may refer to the vst1q_u8_x2 instruction. The vst1q_u8_x2 instruction is a vector storage instruction in the neon instruction set, used to store a vector of multiple 8-bit unsigned integers in memory.

[0048] As described above, the image processing method includes: acquiring several four-view images of a target area, the four-view images including several front view images, several rear view images, several left view images, and several right view images; loading the pixel values ​​and pixel weight values ​​of the four-view images into a neon register using a first neon instruction; processing the pixel weight values ​​and pixel values ​​in the neon register using a neon calculation instruction to obtain bird's-eye view pixel values ​​of the target area; saving the bird's-eye view pixel values ​​into memory using a neon storage instruction; loading the bird's-eye view pixel values ​​from memory using a first neon load instruction; performing a fusion process on the bird's-eye view pixel values ​​using a second neon instruction to obtain fused bird's-eye view pixel values; and loading the fused bird's-eye view pixel values ​​into memory using a second neon load instruction.

[0049] By fusing image pixels based on the neon command, the pixel values ​​of the fused bird's-eye view can be obtained, which can improve the running efficiency of top-down stitching and is suitable for scenarios with high efficiency requirements.

[0050] Figure 3 This is a flowchart illustrating an embodiment of the present disclosure that loads the pixel values ​​and pixel weight values ​​of the four-view image into the neon register using a first neon instruction. For example... Figure 3 As shown, this disclosure provides a method for loading pixel values ​​and pixel weight values ​​of the four-view image into the neon register using a first neon instruction, including:

[0051] Step S21: Load the pixel values ​​of the four-view image into the neon register using the third neon loading instruction.

[0052] Optionally, the method of loading the pixel values ​​of the four-view image into the neon register by the third neon load instruction includes: loading the pixel values ​​of the four-view image from memory into the neon register by the third neon load instruction.

[0053] Optionally, the third neon load instruction may refer to the vld1_u8 instruction. The input parameter of the third neon load instruction can be the sum of the pointer and offset of the pixel values ​​of the four-view image in memory. For example, loading the first row of pixel values ​​of the four-view image in memory can be represented as vld1_u8(src+offest0), where src represents the pointer and offset0 represents the offset. The vld1_u8 instruction is a vector load instruction in the neon instruction set, used to continuously load unsigned 8-bit integers from memory into the neon register.

[0054] Step S22: Load the four-view index into the neon register using the third neon load instruction.

[0055] Optionally, the third neon loading instruction may refer to the vld1_u8 instruction, whose input parameter may be a pointer to the four-view index.

[0056] Step S23: Based on the index in the neon register, query the neon register using a neon lookup table instruction to obtain the pixel value corresponding to that index in the neon register.

[0057] Optionally, the neon lookup instruction may refer to the vtbl4_u8 instruction, whose input parameters may include the index in the neon register and the pixel value in the neon register. The vtbl4_u8 instruction is an inline function in the neon instruction set used to selectively extract data from a 128-bit vector register.

[0058] Step S24: The pixel value in the neon register is saved to memory using the neon storage instruction.

[0059] Optionally, the neon storage instruction may refer to the vst1_u8 instruction, whose input parameters may be the pixel value corresponding to the index and the pointer corresponding to the pixel value.

[0060] Step S25: Load the pixel weight values ​​of the four-view image into the neon register using the fourth neon loading instruction.

[0061] Optionally, the method of loading the pixel weight values ​​of the four-view image into the neon register via the fourth neon load instruction includes: loading the pixel weight values ​​of the four-view image from the memory into the neon register via the fourth neon load instruction.

[0062] Optionally, the fourth neon load instruction can be a vld4_u8 instruction, whose input parameter can be a pointer to the pixel weight values ​​of the four-view image. The vld4_u8 instruction is a function in the neon instruction set used to load four groups of 8-bit unsigned integers from memory into the neon register.

[0063] Step S26: Load the pixel values ​​in memory into the neon register using the fourth neon load instruction.

[0064] Optionally, the fourth neon loading instruction can be a vld4_u8 instruction, the input parameter of which can be a pointer to the pixel value in memory.

[0065] Figure 4 This is a flowchart illustrating an embodiment of the present disclosure of a method for loading the four-view index into the neon register via the third neon load instruction. (See flowchart for details.) Figure 4 As shown, this disclosure provides a method for loading the four-view index into the neon register via the third neon load instruction, including...

[0066] Step S31: Load the Y index into the neon register using the third neon load instruction.

[0067] Optionally, the four-view index includes a Y index, a U index, and a V index. Here, Y represents luminance, U represents the chromaticity component (the blue portion of the image minus luminance), and V represents the chromaticity component (the red portion of the image minus luminance).

[0068] Optionally, the third neon loading instruction refers to the vld1_u8 instruction, whose input parameter can be a pointer to the Y index in the four-view index.

[0069] Step S32: Load the U index into the neon register using the third neon load instruction.

[0070] Optionally, the third neon loading instruction refers to the vld1_u8 instruction, whose input parameter can be a pointer to the U index in the four-view index.

[0071] Step S33: Load the V index into the neon register using the third neon load instruction.

[0072] Optionally, the third neon loading instruction refers to the vld1_u8 instruction, whose input parameter can be a pointer to the V index in the four-view index.

[0073] Figure 5 This is a flowchart illustrating an embodiment of the present disclosure that uses a neon lookup table instruction to query the neon register based on an index in the neon register to obtain the pixel value in the neon register. Figure 5 As shown, this disclosure provides a method for obtaining pixel values ​​in the neon register by querying the neon register using a neon lookup table instruction, including:

[0074] Step S41: Based on the Y index in the neon register, query the neon register using the neon lookup instruction to obtain the Y pixel value in the neon register.

[0075] Optionally, the neon lookup instruction may refer to the vtbl4_u8 instruction, whose input parameters may include the Y index in the neon register and the pixel values ​​of the four-view image in the neon register.

[0076] Step S42: Based on the U index in the neon register, query the neon register using the neon lookup instruction to obtain the U pixel value in the neon register.

[0077] Optionally, the neon lookup instruction may refer to the vtbl4_u8 instruction, whose input parameters may include the U index in the neon register and the pixel values ​​of the four-view image in the neon register.

[0078] Step S43: Based on the V index in the neon register, query the neon register using the neon lookup instruction to obtain the V pixel value in the neon register.

[0079] Optionally, the neon lookup instruction may refer to the vtbl4_u8 instruction, whose input parameters may include the V index in the neon register and the pixel values ​​of the four-view image in the neon register.

[0080] Figure 6This is a flowchart illustrating an embodiment of the present disclosure that uses neon calculation instructions to process pixel weight values ​​and pixel values ​​in the neon register to obtain the bird's-eye view pixel values ​​of the target region. Figure 6 As shown, this disclosure provides a method for processing pixel weight values ​​and pixel values ​​in the neon register using neon calculation instructions to obtain the bird's-eye view pixel values ​​of the target area, including:

[0081] Step S51: Process the Y pixel weight value and the Y pixel value in the neon register using the neon calculation instruction to obtain the bird's-eye view Y pixel value of the target area.

[0082] Optionally, the pixel weight values ​​include Y pixel weight values, U pixel weight values, and V pixel weight values.

[0083] Optionally, the neon calculation instruction may refer to the vmlal_u8 instruction, whose input parameters may include the Y pixel weight value and the Y pixel value.

[0084] Step S52: Process the U-pixel weight value and the U-pixel value in the neon register using the neon calculation instruction to obtain the bird's-eye view U-pixel value of the target area.

[0085] Optionally, the neon calculation instruction may refer to the vmlal_u8 instruction, whose input parameters may include the U-pixel weight value and the U-pixel value.

[0086] Step S53: The V pixel weight value and the V pixel value in the neon register are processed by the neon calculation instruction to obtain the bird's-eye view V pixel value of the target area.

[0087] Optionally, the neon calculation instruction may refer to the vmlal_u8 instruction, whose input parameters may include the V pixel weight value and the V pixel value.

[0088] Figure 7 This is a flowchart illustrating a method for fusing the bird's-eye view pixel values ​​using a second neon instruction, according to an embodiment of this disclosure, to obtain the fused bird's-eye view pixel values. For example... Figure 7 As shown, this disclosure provides a method for fusing the pixel values ​​of the bird's-eye view using a second neon instruction to obtain the fused pixel values ​​of the bird's-eye view, including:

[0089] Step S61: The pixel values ​​of the front view bird's-eye view and the left view bird's-eye view are fused using the second neon instruction to obtain the fused left front part bird's-eye view pixel values.

[0090] Optionally, the bird's-eye view pixel values ​​include front view bird's-eye view pixel values, rear view bird's-eye view pixel values, left view bird's-eye view pixel values, and right view bird's-eye view pixel values.

[0091] Optionally, the second neon instruction may refer to a second neon instruction set, which contains different neon instructions than the first neon instruction set.

[0092] Step S62: The pixel values ​​of the front view bird's-eye view and the right view bird's-eye view are fused using the second neon instruction to obtain the fused right front part bird's-eye view pixel values.

[0093] Step S63: The pixel values ​​of the rear view bird's-eye view and the left view bird's-eye view are fused using the second neon instruction to obtain the fused left rear part bird's-eye view pixel values.

[0094] Step S64: The pixel values ​​of the rear view bird's-eye view and the right view bird's-eye view are fused using the second neon instruction to obtain the fused right rear part bird's-eye view pixel values.

[0095] Optionally, the principle of obtaining the pixel values ​​of the fused right front part bird's-eye view, the pixel values ​​of the fused left rear part bird's-eye view, and the pixel values ​​of the fused right rear part bird's-eye view is similar to the principle of obtaining the pixel values ​​of the fused left front part bird's-eye view, and will not be described again in this embodiment.

[0096] Figure 8 This is a flowchart illustrating an embodiment of the present disclosure that uses the second neon instruction to fuse the pixel values ​​of the front view bird's-eye view and the left view bird's-eye view to obtain the fused left front portion bird's-eye view pixel values. Figure 8 As shown, this disclosure provides a method for fusing the pixel values ​​of the front view bird's-eye view and the left view bird's-eye view using the second neon instruction to obtain the fused left front portion bird's-eye view pixel values, including:

[0097] Step S71: Load the Y pixel value of the front view bird's-eye view into the neon register using the fifth neon loading instruction.

[0098] Optionally, the fifth neon load instruction may refer to the vld1q_u8_x2 instruction, whose input parameter can be a pointer to the pixel values ​​of the front view bird's-eye view. The vld1q_u8_x2 instruction may refer to an instruction in the neon instruction set used to load unsigned 8-bit data from memory into a vector register.

[0099] Step S72: Load the Y pixel value of the left view bird's-eye view into the neon register using the fifth neon loading instruction.

[0100] Optionally, the fifth neon loading instruction may refer to the vld1q_u8_x2 instruction, whose input parameter may be a pointer to the Y pixel value of the left-view bird's-eye view.

[0101] Step S73: The Y pixel values ​​of the front view bird's-eye view and the left view bird's-eye view in the neon register are fused using the neon fusion instruction to obtain the fused Y pixel values ​​of the left front part bird's-eye view.

[0102] Optionally, the neon fusion instruction may refer to the vqaddq_u8 instruction, whose input parameters may include the Y-pixel values ​​of the front view bird's-eye view and the left view bird's-eye view in the neon register. The vqaddq_u8 instruction is an instruction in the neon instruction set, used to perform saturated addition and vector operations on 8-bit unsigned integers.

[0103] Step S74: Load the front view bird's-eye view U pixel value into the neon register using the fifth neon loading instruction.

[0104] Optionally, the fifth neon loading instruction may refer to the vld1q_u8_x2 instruction, whose input parameter may be a pointer to the U pixel value of the front view bird's-eye view.

[0105] Step S75: Load the left view bird's-eye view U pixel value into the neon register using the fifth neon loading instruction.

[0106] Optionally, the fifth neon loading instruction may refer to the vld1q_u8_x2 instruction, whose input parameter may be the U-pixel value of the left-view bird's-eye view.

[0107] Step S76: The front view bird's-eye view U pixel value and the left view bird's-eye view U pixel value in the neon register are fused using the neon fusion instruction to obtain the fused left front part bird's-eye view U pixel value.

[0108] Optionally, the neon fusion instruction may refer to the vqaddq_u8 instruction, whose input parameters may include the U-pixel values ​​of the front view bird's-eye view and the left view bird's-eye view in the neon register.

[0109] Step S77: Load the front view bird's-eye view V pixel value into the neon register using the fifth neon loading instruction.

[0110] Optionally, the fifth neon loading instruction may refer to the vld1q_u8_x2 instruction, whose input parameter may be the V pixel value of the front view bird's-eye view.

[0111] Step S78: Load the left view bird's-eye view V pixel value into the neon register using the fifth neon loading instruction.

[0112] Optionally, the fifth neon loading instruction may refer to the vld1q_u8_x2 instruction, whose input parameter may be the V pixel value of the left-view bird's-eye view.

[0113] Step S79: The front view bird's-eye view V pixel value and the left view bird's-eye view V pixel value in the neon register are fused using the neon fusion instruction to obtain the fused left front part bird's-eye view V pixel value.

[0114] Optionally, the neon fusion instruction may refer to the vqaddq_u8 instruction, whose input parameters may include the V pixel values ​​of the front view bird's-eye view and the left view bird's-eye view in the neon register.

[0115] In one embodiment of this disclosure, the image processing method includes:

[0116] Taking the calculation of pixels in the front left region of the top view as an example:

[0117] 1. Load left view pixel values ​​from DDR into the NEON register (vld1_u8)

[0118] The original image format is UYVY, the image data pointer is uint8_t *srcPtr, and the left view pixel values ​​can be as shown in Table 1 below:

[0119] U Y V Y U Y V Y … U Y V Y U Y V Y … U Y V Y U Y V Y … U Y V Y U Y V Y … … … … … … … … … …

[0120] Table 1

[0121] offset is the pre-calculated offset. NEON image data variable: uint8x8x4_t src_data. The image data is loaded into the NEON register using the following instructions.

[0122] src_data.val[0] = vld1_u8(src + offest0)

[0123] src_data.val[1] = vld1_u8(src + offest1)

[0124] src_data.val[2] = vld1_u8(src + offest2)

[0125] src_data.val[3] = vld1_u8(src + offest3)

[0126] The image data in the NEON register is shown in Table 2 below:

[0127] U Y V Y U Y V Y U Y V Y U Y V Y U Y V Y U Y V Y U Y V Y U Y V Y

[0128] Table 2

[0129] 2. Load the left view index from DDR into the NEON register (vld1_u8)

[0130] y-index data pointer: uint8_t *idx_y, the y-index of the left view is shown in Table 3 below:

[0131] Idx_Y Idx_Y Idx_Y Idx_Y Idx_Y Idx_Y Idx_Y Idx_Y

[0132] Table 3

[0133] The NEON y index data variable is uint8x8_t idx_y_vec. The y index data is loaded into the NEON register by idx_y_vec = vld1_u8(idx_y), as shown in Table 4 below.

[0134] Idx_Y Idx_Y Idx_Y Idx_Y Idx_Y Idx_Y Idx_Y Idx_Y

[0135] Table 4

[0136] u-index data pointer: uint8_t *idx_u, the u-index of the left view is shown in Table 5 below:

[0137] Idx_U Idx_U Idx_U Idx_U Idx_U Idx_U Idx_U Idx_U

[0138] Table 5

[0139] NEONU index data variable: uint8x8_t idx_u_vec. The u-index data is loaded into the NEON register by idx_u_vec = vld1_u8(idx_u), as shown in Table 6 below:

[0140] Idx_U Idx_U Idx_U Idx_U Idx_U Idx_U Idx_U Idx_U

[0141] Table 6

[0142] v index data pointer: uint8_t *idx_v, the v index of the left view is shown in Table 7 below:

[0143] Idx_V Idx_V Idx_Y Idx_V Idx_V Idx_V Idx_V Idx_V

[0144] Table 7

[0145] The NEON v index data variable is uint8x8_t idx_v_vec. The v index data is loaded into the NEON register by idx_v_vec = vld1_u8(idx_v), as shown in Table 8 below.

[0146] Idx_V Idx_V Idx_Y Idx_V Idx_V Idx_V Idx_V Idx_V

[0147] Table 8

[0148] 3. Retrieve the desired data from the table (vtbl4_u8)

[0149] U Y V Y U Y V Y U Y V Y U Y V Y U Y V Y U Y V Y U Y V Y U Y V Y

[0150] Table 9

[0151] NEON Y data variable: uint8x8_t y_vec, obtained through the instruction y_vec = vtbl4_u8(src_data,idx_y_vec), as shown in Table 10 below:

[0152] Y Y Y Y Y Y Y Y

[0153] Table 10

[0154] NEON U data variables: uint8x8_t u_vec, obtained through the instruction u_vec = vtbl4_u8(src_data,idx_u_vec), as shown in Table 11 below:

[0155] U U U U U U U U

[0156] Table 11

[0157] NEON V data variable: uint8x8_t v_vec, obtained by v_vec = vtbl4_u8(src_data, idx_v_vec) as shown in Table 12 below:

[0158] V V V V V V V V

[0159] Table 12

[0160] 4. Save the data to DDR (vst1_u8)

[0161] Y component data pointer: uint8_t *yPtr. Based on the y in Table 10, the y in DDR is obtained through the instruction vst1_u8(yPtr, y_vec), as shown in Table 13 below:

[0162] Y Y Y Y Y Y Y Y … … … … … … … … … …

[0163] Table 13

[0164] U-component data pointer: uint8_t *uPtr. Based on u in Table 11, u in DDR is obtained through the instruction vst1_u8(uPtr, u_vec), as shown in Table 14 below:

[0165] U U U U U U U U … … … … … … … … … …

[0166] Table 14

[0167] V component data pointer: uint8_t *vPtr. Based on v in Table 12, v in DDR is obtained through the instruction vst1_u8(vPtr, v_vec), as shown in Table 15 below:

[0168] V V V V V V V V … … … … … … … … … …

[0169] Table 15

[0170] Repeat steps 1, 2, 3, and 4 to obtain all Y, U, and V components and save them to DDR.

[0171] 5. Load the left view pixel weight values ​​from DDR into the NEON register (vld4_u8)

[0172] Weight data pointer: uint8_t *wPtr, the pixel weight values ​​of the left view are shown in Table 16 below:

[0173] W W W W W W W W … W W W W W W W W … W W W W W W W W … W W W W W W W W … … … … … … … … … …

[0174] Table 16

[0175] NEON weight data variable: uint8x8x4_t w_vec. The weight data is loaded into the NEON register by the instruction w_vec = vld4_u8(wPtr), as shown in Table 17 below:

[0176] W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W

[0177] Table 17

[0178] 6. Load the Y, U, V component values ​​obtained in step 4 from DDR into the NEON register (vld4_u8).

[0179] Y component data pointer: uint8_t *yPtr, Y component data is shown in Table 18 below:

[0180] Y Y Y Y Y Y Y Y … Y Y Y Y Y Y Y Y … Y Y Y Y Y Y Y Y … Y Y Y Y Y Y Y Y … … … … … … … … … …

[0181] Table 18

[0182] NEON Y component data variable: uint8x8x4_t y_vec. The Y component data is loaded into the NEON register by the instruction y_vec = vld4_u8(yPtr), as shown in Table 19 below:

[0183] Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y

[0184] Table 19

[0185] U-component data pointer: uint8_t *uPtr, U-component data is shown in Table 20 below:

[0186] U U U U U U U U … U U U U U U U U … U U U U U U U U … U U U U U U U U … … … … … … … … … …

[0187] Table 20

[0188] NEON U-component data variables: uint8x8x4_t u_vec, the U-component data is loaded into the NEON register by the instruction u_vec = vld4_u8(uPtr), as shown in Table 21 below:

[0189] U U U U U U U U U U U U U U U U U U U U U U U U U U U U U U U U

[0190] Table 21

[0191] V component data pointer: uint8_t *vPtr, V component data is shown in Table 22 below:

[0192] V V V V V V V V … V V V V V V V V … V V V V V V V V … V V V V V V V V … … … … … … … … … …

[0193] Table 22

[0194] NEON V component data variable: uint8x8x4_t v_vec, the V component data is loaded into the NEON register by the instruction v_vec = vld4_u8(vPtr), as shown in Table 23 below:

[0195] V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V V

[0196] Table 23

[0197] 7. Obtain new Y, U, and V components (vdupq_n_u16, vmlal_u8, vshrq_n_u16) through bilinear interpolation. The Y component in Table 19 and the W component in Table 17 are compared using the following command to obtain the new Y component value, as shown in Table 24 below: tem_y = vdupq_n_u16(0);

[0198] tem_y = vmlal_u8(tem_y, y_vec.val[0], w_vec.val[0])

[0199] tem_y = vmlal_u8(tem_y, y_vec.val[1], w_vec.val[1])

[0200] tem_y = vmlal_u8(tem_y, y_vec.val[2], w_vec.val[2])

[0201] tem_y = vmlal_u8(tem_y, y_vec.val[3], w_vec.val[3])

[0202] out_y_vec = vshrn_n_u16(tem_y, 8)

[0203] Y Y Y Y Y Y Y Y

[0204] Table 24

[0205] NEON Y new component data variable: uint8x8x4_t out_y_vec, NEON Y temporary component data variable: uint16x8_t tem_y.

[0206] The U component in Table 21 and the W component in Table 17 are used to obtain new U component values ​​as shown in Table 25 below using the following command: tem_u = vdupq_n_u16(0);

[0207] tem_u = vmlal_u8(tem_u, u_vec.val[0], w_vec.val[0])

[0208] tem_u = vmlal_u8(tem_u, u_vec.val[1], w_vec.val[1])

[0209] tem_u = vmlal_u8(tem_u, u_vec.val[2], w_vec.val[2])

[0210] tem_u = vmlal_u8(tem_u, u_vec.val[3], w_vec.val[3])

[0211] out_u_vec = vshrn_n_u16(tem_u, 8)

[0212] U U U U U U U U

[0213] Table 25

[0214] NEON U new component data variable: uint8x8x4_t out_u_vec, NEON U temporary component data variable: uint16x8_t tem_u.

[0215] The V component in Table 23 and the W component in Table 17 are used to obtain new V component values ​​as shown in Table 26 below using the following command: tem_v = vdupq_n_u16(0);

[0216] tem_v = vmlal_u8(tem_v, v_vec.val[0], w_vec.val[0])

[0217] tem_v = vmlal_u8(tem_v, v_vec.val[1], w_vec.val[1])

[0218] tem_v = vmlal_u8(tem_v, v_vec.val[2], w_vec.val[2])

[0219] tem_v = vmlal_u8(tem_v, v_vec.val[3], w_vec.val[3])

[0220] out_v_vec = vshrn_n_u16(tem_v, 8)

[0221] V V V V V V V V

[0222] Table 26

[0223] NEON V new component data variable: uint8x8x4_t out_v_vec, NEON U temporary component data variable: uint16x8_t tem_v.

[0224] 8. Save the data to DDR (vst1_u8)

[0225] Y component data pointer: uint8_t *yPtr, which saves the Y component data from Table 24 to DDR using the instruction vst1_u8(yPtr, y_vec), as shown in Table 27 below:

[0226] Y Y Y Y Y Y Y Y … … … … … … … … … …

[0227] Table 27

[0228] U-component data pointer: uint8_t *uPtr, which saves the U in Table 25 to DDR using the instruction vst1_u8(uPtr, u_vec ), as shown in Table 28 below:

[0229] U U U U U U U U … … … … … … … … … …

[0230] Table 28

[0231] V component data pointer: uint8_t *vPtr, which saves the V component data from Table 26 to DDR using the instruction vst1_u8(vPtr, v_vec), as shown in Table 29 below:

[0232] V V V V V V V V … … … … … … … … … …

[0233] Table 29

[0234] Repeat steps 5, 6, 7, and 8 to obtain all Y, U, and V components and save them to DDR.

[0235] 9. Merge (vld1q_u8_x2, vqaddq_u8, vst1q_u8_x2)

[0236] Performing steps 1-8 twice will yield the Y, U, and V component values ​​of the left and front views in the top view. Merging these two sets of values ​​will produce a top-view stitched image in YUV format.

[0237] a. Load the Y, U, V component values ​​(vld1q_u8_x2) of the left and front views in the top view.

[0238] Left view Y component data pointer: uint8_t *y0Ptr, NEON Y0 component data variable: uint8x16x2_ty0_vec. The left view Y component data in Table 27 is loaded into the NEON register by the instruction y0_vec = vld1q_u8_x2(y0Ptr), as shown in Table 30 below:

[0239] Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y

[0240] Table 30

[0241] Front view Y component data pointer: uint8_t *y1Ptr, NEON Y1 component data variable: uint8x16x2_ty1_vec. The front view Y component data in Table 27 is loaded into the NEON register by the instruction y1_vec = vld1q_u8_x2(y1Ptr), as shown in Table 31 below:

[0242] Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y

[0243] Table 31

[0244] Left view U component data pointer: uint8_t *u0Ptr, NEON U0 component data variable: uint8x16x2_tu0_vec. The left view U component data in Table 28 is loaded into the NEON register by the instruction u0_vec = vld1q_u8_x2(u0Ptr), as shown in Table 32 below:

[0245] U U U U U U U U U U U U U U U U

[0246] Table 32

[0247] Front view U component data pointer: uint8_t *u1Ptr, NEON U1 component data variable: uint8x16x2_tu1_vec. The front view U component data in Table 28 is loaded into the NEON register by the instruction u1_vec = vld1q_u8_x2(u1Ptr), as shown in Table 33 below:

[0248] U U U U U U U U U U U U U U U U

[0249] Table 33

[0250] Left view V component data pointer: uint8_t *v0Ptr, NEON V0 component data variable: uint8x16x2_tv0_vec. The left view V component data in Table 29 is loaded into the NEON register by the instruction v0_vec = vld1q_u8_x2(v0Ptr), as shown in Table 34 below:

[0251] V V V V V V V V V V V V V V V V

[0252] Table 34

[0253] Front view V component data pointer: uint8_t *v1Ptr, NEON V1 component data variable: uint8x16x2_tv1_vec. The front view V component data in Table 29 is loaded into the NEON register by the instruction v1_vec = vld1q_u8_x2(v1Ptr), as shown in Table 35 below:

[0254] V V V V V V V V V V V V V V V V

[0255] Table 35

[0256] b. Merge the Y, U, V component values ​​of the left view and the front view in the top view (vqaddq_u8)

[0257] By using the commands out_y.val[0] = vqaddq_u8(y0_vec.val[0], y1_vec.val[0]) and out_y.val[1] = vqaddq_u8(y0_vec.val[1], y1_vec.val[1]), the Y values ​​in Tables 30 and 31 are merged to obtain the merged NEON Y component data variable: uint8x16x2_t out_y, as shown in Table 36 below:

[0258] Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y

[0259] Table 36

[0260] By using the commands out_u.val[0] = vqaddq_u8(u0_vec.val[0], u1_vec.val[0]) and out_u.val[1] = vqaddq_u8(u0_vec.val[1], u1_vec.val[1]), the U values ​​in Tables 32 and 33 are merged to obtain the merged NEON U component data variables: uint8x16x2_t out_u, as shown in Table 37 below:

[0261] U U U U U U U U U U U U U U U U

[0262] Table 37

[0263] By using the commands out_v.val[0] = vqaddq_u8(v0_vec.val[0], v1_vec.val[0]) and out_v.val[1] = vqaddq_u8(v0_vec.val[1], v1_vec.val[1]), the V values ​​in Tables 34 and 35 are merged to obtain the merged NEON V component data variable: uint8x16x2_t out_v, as shown in Table 38 below:

[0264] V V V V V V V V V V V V V V V V

[0265] Table 38

[0266] c. Save the final top view YUV values ​​to DDR (vst1q_u8_x2)

[0267] Y component data pointer: uint8_t *yPtr, which uses the instruction vst1q_u8_x2(yPtr, out_y) to save the Y component data from Table 36 to DDR, as shown in Table 39 below:

[0268] Y Y Y Y Y Y Y Y … Y Y Y Y Y Y Y Y … … … … … … … … … …

[0269] Table 39

[0270] U-component data pointer: uint8_t *uPtr, which uses the instruction vst1q_u8_x2(uPtr, out_u) to save the U-components from Table 37 to DDR, as shown in Table 40 below:

[0271] U U U U U U U U … U U U U U U U U … … … … … … … … … …

[0272] Table 40

[0273] V component data pointer: uint8_t *vPtr, which uses the instruction vst1q_u8_x2(vPtr, out_v) to save the V component data from Table 38 to DDR, as shown in Table 41 below:

[0274] V V V V V V V V … V V V V V V V V … … … … … … … … … …

[0275] Table 41

[0276] Repeat steps a, b, and c to obtain all Y, U, and V values ​​and save them to DDR.

[0277] Figure 9 This is a schematic diagram illustrating the structure of an image processing apparatus 900 according to an embodiment of the present disclosure. Figure 9 As shown, the image processing device 900 includes:

[0278] The image acquisition module 910 is used to acquire four-view images of the target area, including several front view images, several rear view images, several left view images, and several right view images.

[0279] The pixel first loading module 920 is used to load the pixel values ​​and pixel weight values ​​of the four-view image into the neon register through the first neon instruction.

[0280] The pixel processing module 930 is used to process the pixel weight value and pixel value in the neon register through neon calculation instructions to obtain the bird's-eye view pixel value of the target area.

[0281] The first pixel storage module 940 is used to save the pixel values ​​of the bird's-eye view to memory via the neon storage instruction.

[0282] The second pixel loading module 950 is used to load the bird's-eye view pixel values ​​in memory via the first neon loading instruction.

[0283] The pixel fusion module 960 is used to perform fusion processing on the bird's-eye view pixel values ​​through the second neon instruction to obtain the fused bird's-eye view pixel values.

[0284] The second pixel storage module 970 is used to load the fused bird's-eye view pixel values ​​into the memory via a second neon loading instruction.

[0285] In the image processing apparatus 900, the image acquisition module 910 and Figure 2 The image processing method has one-to-one correspondences with step S11, the first pixel loading module 920 corresponds to step S12, the pixel processing module 930 corresponds to step S13, the first pixel storage module 940 corresponds to step S14, the second pixel loading module 950 corresponds to step S15, the pixel fusion module 960 corresponds to step S16, and the second pixel storage module 970 corresponds to step S17.

[0286] Figure 10 The diagram shown is a structural schematic of an electronic device according to an embodiment of this disclosure. Figure 10 As shown, the electronic device provided in this embodiment includes a processor and a memory. The memory is configured to store an executable program. The processor is configured to execute the program to cause the electronic device to perform the image processing method according to any of the preceding claims.

[0287] Preferably, the processor can be a general-purpose processor, including a central processing unit (CPU), a network processor (NP), etc.; it can also be a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. The memory can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk.

[0288] This embodiment also includes one or more of the following: multimedia components, input / output (I / O) interfaces, and communication components.

[0289] The multimedia component may include a screen and an audio component. The screen may be, for example, a touchscreen, and the audio component is configured to output and / or input audio signals. For example, the audio component may include a microphone configured to receive external audio signals. The received audio signals may be further stored in memory or transmitted via a communication component. The audio component also includes at least one speaker configured to output audio signals. The I / O interface provides an interface between the processor and other interface modules, such as a keyboard, mouse, buttons, etc. These buttons may be virtual or physical buttons. The communication component is configured to enable wired or wireless communication between the timer and other devices. Wireless communication may include Wi-Fi, Bluetooth, Near Field Communication (NFC), 2G, 3G, or 4G, or a combination thereof; therefore, the corresponding communication component may include a Wi-Fi module, a Bluetooth module, or an NFC module.

[0290] In the several embodiments provided in this disclosure, it should be understood that the disclosed systems, apparatuses, or methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of modules / units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple modules or units may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection of apparatuses or modules or units may be electrical, mechanical, or other forms.

[0291] The modules / units described as separate components may or may not be physically separate. The components shown as modules / units may or may not be physical modules; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules / units can be selected to achieve the objectives of the embodiments of this disclosure, depending on actual needs. For example, the functional modules / units in the various embodiments of this disclosure may be integrated into one processing module, or each module / unit may exist physically separately, or two or more modules / units may be integrated into one module / unit.

[0292] Those skilled in the art will further recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this disclosure.

[0293] This disclosure also provides a computer-readable storage medium storing a computer program thereon. When executed by a processor, the computer program implements the image processing method and apparatus, electronic device, and storage medium provided in this disclosure. Those skilled in the art will understand that all or part of the steps in the methods of the above embodiments can be implemented by a program instructing a processor. The program can be stored in a computer-readable storage medium, which is a non-transitory medium, such as random access memory, read-only memory, flash memory, hard disk, solid-state drive, magnetic tape, floppy disk, optical disk, and any combination thereof. The storage medium can be any available medium accessible to a computer or a data storage device such as a server or data center that integrates one or more available media. The available medium can be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., digital video disc (DVD)), or a semiconductor medium (e.g., solid-state disk (SSD)).

[0294] The above embodiments are merely illustrative of the principles and effects of this disclosure and are not intended to limit this disclosure. Any person skilled in the art can modify or alter the above embodiments without departing from the spirit and scope of this disclosure. Therefore, all equivalent modifications or alterations made by those skilled in the art without departing from the spirit and technical concept disclosed in this disclosure should still be covered by the claims of this disclosure.

Claims

1. An image processing method, characterized by, The method comprises: acquiring a four-view image of a target region, the four-view image comprising a plurality of front-view images, a plurality of back-view images, a plurality of left-view images and a plurality of right-view images; loading pixel values and pixel weight values of the four-view image into a neon register through a first neon instruction; processing the pixel weight values and the pixel values in the neon register through a neon calculation instruction to obtain aerial view pixel values of the target region; storing the aerial view pixel values in the memory through a neon storage instruction; loading the aerial view pixel values in the memory through a first neon loading instruction; fusing the aerial view pixel values through a second neon instruction to obtain fused aerial view pixel values; storing the fused aerial view pixel values in the memory through a second neon loading instruction.

2. The image processing method of claim 1, wherein, The implementation method of loading the pixel values and the pixel weight values of the four-view image into the neon register through the first neon instruction comprises: loading the pixel values of the four-view image into the neon register through the third neon loading instruction; loading the four-view indexes into the neon register through the third neon loading instruction; querying the neon register based on the indexes in the neon register through a neon lookup instruction to obtain pixel values corresponding to the indexes in the neon register; storing the pixel values in the neon register into the memory through a neon storage instruction; loading the pixel weight values of the four-view image into the neon register through a fourth neon loading instruction; loading the pixel values in the memory into the neon register through the fourth neon loading instruction.

3. The image processing method of claim 2, wherein, The implementation method of loading the four-view indexes into the neon register through the third neon loading instruction comprises: the four-view indexes comprise Y indexes, U indexes and V indexes; loading the Y indexes into the neon register through the third neon loading instruction; loading the U indexes into the neon register through the third neon loading instruction; loading the V indexes into the neon register through the third neon loading instruction.

4. The image processing method of claim 3, wherein, The implementation method of querying the neon register based on the indexes in the neon register through a neon lookup instruction to obtain pixel values in the neon register comprises: querying the neon register based on the Y indexes in the neon register through the neon lookup instruction to obtain Y pixel values in the neon register; querying the neon register based on the U indexes in the neon register through the neon lookup instruction to obtain U pixel values in the neon register; querying the neon register based on the V indexes in the neon register through the neon lookup instruction to obtain V pixel values in the neon register.

5. The image processing method of claim 4, wherein, The implementation method for processing the pixel weight values and the pixel values in the neon register by neon computing instructions to obtain the bird's eye view pixel values of the target region comprises: The pixel weight values comprise Y pixel weight values, U pixel weight values and V pixel weight values; The implementation method for processing the Y pixel weight values and the Y pixel values in the neon register by the neon computing instructions to obtain the bird's eye view Y pixel values of the target region comprises: The implementation method for processing the U pixel weight values and the U pixel values in the neon register by the neon computing instructions to obtain the bird's eye view U pixel values of the target region comprises: The implementation method for processing the V pixel weight values and the V pixel values in the neon register by the neon computing instructions to obtain the bird's eye view V pixel values of the target region comprises.

6. The image processing method of claim 5, wherein, The implementation method for fusing the bird's eye view pixel values by a second neon instruction to obtain fused bird's eye view pixel values comprises: The bird's eye view pixel values comprise front view bird's eye view pixel values, rear view bird's eye view pixel values, left view bird's eye view pixel values and right view bird's eye view pixel values; The implementation method for fusing the front view bird's eye view pixel values and the left view bird's eye view pixel values by the second neon instruction to obtain the fused left front partial bird's eye view pixel values comprises: The implementation method for fusing the front view bird's eye view pixel values and the right view bird's eye view pixel values by the second neon instruction to obtain the fused right front partial bird's eye view pixel values comprises: The implementation method for fusing the rear view bird's eye view pixel values and the left view bird's eye view pixel values by the second neon instruction to obtain the fused left rear partial bird's eye view pixel values comprises: The implementation method for fusing the rear view bird's eye view pixel values and the right view bird's eye view pixel values by the second neon instruction to obtain the fused right rear partial bird's eye view pixel values comprises.

7. The image processing method of claim 6, wherein, The implementation method for fusing the front view bird's eye view pixel values and the left view bird's eye view pixel values by the second neon instruction to obtain the fused left front partial bird's eye view pixel values comprises: The front view bird's eye view Y pixel values are loaded into the neon register by a fifth neon loading instruction; The left view bird's eye view Y pixel values are loaded into the neon register by the fifth neon loading instruction; The front view bird's eye view Y pixel values and the left view bird's eye view Y pixel values in the neon register are fused by a neon fusion instruction to obtain fused left front partial bird's eye view Y pixel values; The front view bird's eye view U pixel values are loaded into the neon register by the fifth neon loading instruction; The left view bird's eye view U pixel values are loaded into the neon register by the fifth neon loading instruction; The front view bird's eye view U pixel values and the left view bird's eye view U pixel values in the neon register are fused by the neon fusion instruction to obtain fused left front partial bird's eye view U pixel values; load the front view aerial view V pixel values to the neon register through the fifth neon load instruction; load the left view aerial view V pixel values to the neon register through the fifth neon load instruction; fuse the front view aerial view V pixel values and the left view aerial view V pixel values in the neon register through the neon fusion instruction to obtain fused left front partial aerial view V pixel values.

8. An image processing apparatus characterized by comprising: comprising: an image acquisition module, configured to acquire four-view images of a target region, the four-view images comprising a plurality of front view images, a plurality of back view images, a plurality of left view images and a plurality of right view images; a first pixel loading module, configured to load pixel values and pixel weight values of the four-view images into a neon register through a first neon instruction; a pixel processing module, configured to process the pixel weight values and the pixel values in the neon register through a neon calculation instruction to obtain aerial view pixel values of the target region; a first pixel saving module, configured to save the aerial view pixel values into a memory through a neon storage instruction; a second pixel loading module, configured to load the aerial view pixel values in the memory through a first neon load instruction; a pixel fusion module, configured to perform fusion processing on the aerial view pixel values through a second neon instruction to obtain fused aerial view pixel values; a second pixel saving module, configured to save the fused aerial view pixel values into the memory through a second neon load instruction.

9. A computer-readable storage medium having stored thereon a computer program, characterized in that, The computer program is executed by a processor to implement the image processing method according to any one of claims 1 to 7.

10. An electronic device, comprising: comprising: a memory configured to store information associated with an image; a processor electrically coupled to the memory and configured to execute the image processing method according to any one of claims 1 to 7.

Images